// $ANTLR 3.5.2 PLSQLLexer.g 2021-01-30 21:54:47

/**
 * Oracle(c) PL/SQL 11g Parser  
 *
 * Copyright (c) 2009-2011 Alexandre Porcelli <alexandre.porcelli@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package br.com.porcelli.parser.plsql;

import java.util.LinkedList;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

/**
 * Oracle(c) PL/SQL 11g Parser  
 *
 * Copyright (c) 2009-2011 Alexandre Porcelli <alexandre.porcelli@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@SuppressWarnings("all")
public class PLSQLLexer extends Lexer {
	public static final int EOF=-1;
	public static final int AMPERSAND=4;
	public static final int APPROXIMATE_NUM_LIT=5;
	public static final int ASSIGN_OP=6;
	public static final int ASTERISK=7;
	public static final int AT_SIGN=8;
	public static final int BINDVAR=9;
	public static final int BIT_STRING_LIT=10;
	public static final int CARRET_OPERATOR_PART=11;
	public static final int CHAR_STRING=12;
	public static final int CHAR_STRING_PERL=13;
	public static final int COLON=14;
	public static final int COMMA=15;
	public static final int COMMENT=16;
	public static final int CONCATENATION_OP=17;
	public static final int DELIMITED_ID=18;
	public static final int DOUBLE_ASTERISK=19;
	public static final int DOUBLE_PERIOD=20;
	public static final int EQUALS_OP=21;
	public static final int EXACT_NUM_LIT=22;
	public static final int EXCLAMATION_OPERATOR_PART=23;
	public static final int FOR_NOTATION=24;
	public static final int GREATER_THAN_OP=25;
	public static final int GREATER_THAN_OR_EQUALS_OP=26;
	public static final int HEX_STRING_LIT=27;
	public static final int INTRODUCER=28;
	public static final int LEFT_BRACKET=29;
	public static final int LEFT_PAREN=30;
	public static final int LESS_THAN_OP=31;
	public static final int LESS_THAN_OR_EQUALS_OP=32;
	public static final int MINUS_SIGN=33;
	public static final int NATIONAL_CHAR_STRING_LIT=34;
	public static final int NEWLINE=35;
	public static final int NOT_EQUAL_OP=36;
	public static final int PERCENT=37;
	public static final int PERIOD=38;
	public static final int PLSQL_NON_RESERVED_CAST=39;
	public static final int PLSQL_NON_RESERVED_CONNECT_BY_ROOT=40;
	public static final int PLSQL_NON_RESERVED_ELSIF=41;
	public static final int PLSQL_NON_RESERVED_MODEL=42;
	public static final int PLSQL_NON_RESERVED_MULTISET=43;
	public static final int PLSQL_NON_RESERVED_PIVOT=44;
	public static final int PLSQL_NON_RESERVED_UNPIVOT=45;
	public static final int PLSQL_NON_RESERVED_USING=46;
	public static final int PLSQL_RESERVED_CLUSTERS=47;
	public static final int PLSQL_RESERVED_COLAUTH=48;
	public static final int PLSQL_RESERVED_COMPRESS=49;
	public static final int PLSQL_RESERVED_CRASH=50;
	public static final int PLSQL_RESERVED_EXCLUSIVE=51;
	public static final int PLSQL_RESERVED_IDENTIFIED=52;
	public static final int PLSQL_RESERVED_IF=53;
	public static final int PLSQL_RESERVED_INDEX=54;
	public static final int PLSQL_RESERVED_INDEXES=55;
	public static final int PLSQL_RESERVED_LOCK=56;
	public static final int PLSQL_RESERVED_MINUS=57;
	public static final int PLSQL_RESERVED_MODE=58;
	public static final int PLSQL_RESERVED_NOCOMPRESS=59;
	public static final int PLSQL_RESERVED_NOWAIT=60;
	public static final int PLSQL_RESERVED_RESOURCE=61;
	public static final int PLSQL_RESERVED_SHARE=62;
	public static final int PLSQL_RESERVED_START=63;
	public static final int PLSQL_RESERVED_TABAUTH=64;
	public static final int PLSQL_RESERVED_VIEWS=65;
	public static final int PLUS_SIGN=66;
	public static final int PROMPT=67;
	public static final int QS_ANGLE=68;
	public static final int QS_BRACE=69;
	public static final int QS_BRACK=70;
	public static final int QS_OTHER=71;
	public static final int QS_OTHER_CH=72;
	public static final int QS_PAREN=73;
	public static final int QUESTION_MARK=74;
	public static final int QUOTE=75;
	public static final int REGULAR_ID=76;
	public static final int RIGHT_BRACKET=77;
	public static final int RIGHT_PAREN=78;
	public static final int SEMICOLON=79;
	public static final int SEPARATOR=80;
	public static final int SIMPLE_LETTER=81;
	public static final int SOLIDUS=82;
	public static final int SPACE=83;
	public static final int SQL92_RESERVED_ALL=84;
	public static final int SQL92_RESERVED_ALTER=85;
	public static final int SQL92_RESERVED_AND=86;
	public static final int SQL92_RESERVED_ANY=87;
	public static final int SQL92_RESERVED_AS=88;
	public static final int SQL92_RESERVED_ASC=89;
	public static final int SQL92_RESERVED_BEGIN=90;
	public static final int SQL92_RESERVED_BETWEEN=91;
	public static final int SQL92_RESERVED_BY=92;
	public static final int SQL92_RESERVED_CASE=93;
	public static final int SQL92_RESERVED_CHECK=94;
	public static final int SQL92_RESERVED_CONNECT=95;
	public static final int SQL92_RESERVED_CREATE=96;
	public static final int SQL92_RESERVED_CURRENT=97;
	public static final int SQL92_RESERVED_CURSOR=98;
	public static final int SQL92_RESERVED_DATE=99;
	public static final int SQL92_RESERVED_DECLARE=100;
	public static final int SQL92_RESERVED_DEFAULT=101;
	public static final int SQL92_RESERVED_DELETE=102;
	public static final int SQL92_RESERVED_DESC=103;
	public static final int SQL92_RESERVED_DISTINCT=104;
	public static final int SQL92_RESERVED_DROP=105;
	public static final int SQL92_RESERVED_ELSE=106;
	public static final int SQL92_RESERVED_END=107;
	public static final int SQL92_RESERVED_EXCEPTION=108;
	public static final int SQL92_RESERVED_EXISTS=109;
	public static final int SQL92_RESERVED_FALSE=110;
	public static final int SQL92_RESERVED_FETCH=111;
	public static final int SQL92_RESERVED_FOR=112;
	public static final int SQL92_RESERVED_FROM=113;
	public static final int SQL92_RESERVED_GOTO=114;
	public static final int SQL92_RESERVED_GRANT=115;
	public static final int SQL92_RESERVED_GROUP=116;
	public static final int SQL92_RESERVED_HAVING=117;
	public static final int SQL92_RESERVED_IN=118;
	public static final int SQL92_RESERVED_INSERT=119;
	public static final int SQL92_RESERVED_INTERSECT=120;
	public static final int SQL92_RESERVED_INTO=121;
	public static final int SQL92_RESERVED_IS=122;
	public static final int SQL92_RESERVED_LIKE=123;
	public static final int SQL92_RESERVED_NOT=124;
	public static final int SQL92_RESERVED_NULL=125;
	public static final int SQL92_RESERVED_OF=126;
	public static final int SQL92_RESERVED_ON=127;
	public static final int SQL92_RESERVED_OPTION=128;
	public static final int SQL92_RESERVED_OR=129;
	public static final int SQL92_RESERVED_ORDER=130;
	public static final int SQL92_RESERVED_OVERLAPS=131;
	public static final int SQL92_RESERVED_PRIOR=132;
	public static final int SQL92_RESERVED_PROCEDURE=133;
	public static final int SQL92_RESERVED_PUBLIC=134;
	public static final int SQL92_RESERVED_REVOKE=135;
	public static final int SQL92_RESERVED_SELECT=136;
	public static final int SQL92_RESERVED_SIZE=137;
	public static final int SQL92_RESERVED_TABLE=138;
	public static final int SQL92_RESERVED_THE=139;
	public static final int SQL92_RESERVED_THEN=140;
	public static final int SQL92_RESERVED_TO=141;
	public static final int SQL92_RESERVED_TRUE=142;
	public static final int SQL92_RESERVED_UNION=143;
	public static final int SQL92_RESERVED_UNIQUE=144;
	public static final int SQL92_RESERVED_UPDATE=145;
	public static final int SQL92_RESERVED_VALUES=146;
	public static final int SQL92_RESERVED_VIEW=147;
	public static final int SQL92_RESERVED_WHEN=148;
	public static final int SQL92_RESERVED_WHERE=149;
	public static final int SQL92_RESERVED_WITH=150;
	public static final int TILDE_OPERATOR_PART=151;
	public static final int UNDERSCORE=152;
	public static final int UNSIGNED_INTEGER=153;
	public static final int VERTICAL_BAR=154;
	public static final int ZV=155;

	    // buffer (queue) to hold the emit()'d tokens
	    private LinkedList<Token> tokenBuffer = new LinkedList<Token>();

	    public void emit(Token t) {
	        tokenBuffer.add(t);
	    }

	    private void advanceInput(){
	        state.tokenStartCharIndex = input.index();
	        state.tokenStartCharPositionInLine = input.getCharPositionInLine();
	        state.tokenStartLine = input.getLine();
	    }


	    /**
	     * Return a token from this source; i.e., match a token on the char stream.
	     */
	    public Token nextToken() {
	        while (true) {
	            if (tokenBuffer.size() == 0) {
	                state.token = null;
	                state.channel = Token.DEFAULT_CHANNEL;
	                state.tokenStartCharIndex = input.index();
	                state.tokenStartCharPositionInLine = input.getCharPositionInLine();
	                state.tokenStartLine = input.getLine();
	                state.text = null;
	                if (input.LA(1) == CharStream.EOF) {
	                    return getEOFToken();
	                }
	                try {
	                    int m = input.mark();
	                    state.backtracking = 1;
	                    state.failed = false;
	                    mTokens();
	                    state.backtracking = 0;

	                    if (state.failed) {
	                        input.rewind(m);
	                        input.consume();
	                    } else {
	                        emit();
	                    }
	                } catch (RecognitionException re) {
	                    // shouldn't happen in backtracking mode, but...
	                    reportError(re);
	                    recover(re);
	                }
	            } else {
	                Token result = tokenBuffer.poll();
	                if (result == Token.SKIP_TOKEN || result.getType() == Token.INVALID_TOKEN_TYPE || result == null)
	                {
	                    // discard
	                    // SKIP & INVALID
	                    // tokens
	                    continue;
	                }
	                return result;
	            }
	        }
	    }


	// delegates
	// delegators
	public Lexer[] getDelegates() {
		return new Lexer[] {};
	}

	public PLSQLLexer() {} 
	public PLSQLLexer(CharStream input) {
		this(input, new RecognizerSharedState());
	}
	public PLSQLLexer(CharStream input, RecognizerSharedState state) {
		super(input,state);
	}
	@Override public String getGrammarFileName() { return "PLSQLLexer.g"; }

	// $ANTLR start "FOR_NOTATION"
	public final void mFOR_NOTATION() throws RecognitionException {
		try {
			int _type = FOR_NOTATION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:115:5: ( UNSIGNED_INTEGER '..' ( UNSIGNED_INTEGER | REGULAR_ID )? )
			// PLSQLLexer.g:115:10: UNSIGNED_INTEGER '..' ( UNSIGNED_INTEGER | REGULAR_ID )?
			{
			mUNSIGNED_INTEGER(); 

			state.type = UNSIGNED_INTEGER; emit(); advanceInput();
			match(".."); 

			state.type = DOUBLE_PERIOD; emit(); advanceInput();
			// PLSQLLexer.g:119:9: ( UNSIGNED_INTEGER | REGULAR_ID )?
			int alt1=3;
			int LA1_0 = input.LA(1);
			if ( ((LA1_0 >= '0' && LA1_0 <= '9')) ) {
				alt1=1;
			}
			else if ( ((LA1_0 >= 'A' && LA1_0 <= 'Z')||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) {
				alt1=2;
			}
			switch (alt1) {
				case 1 :
					// PLSQLLexer.g:119:11: UNSIGNED_INTEGER
					{
					mUNSIGNED_INTEGER(); 

					state.type = UNSIGNED_INTEGER; emit(); advanceInput(); 
					}
					break;
				case 2 :
					// PLSQLLexer.g:121:11: REGULAR_ID
					{
					mREGULAR_ID(); 

					state.type = REGULAR_ID; emit(); advanceInput(); 
					}
					break;

			}

			 _channel=HIDDEN; 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "FOR_NOTATION"

	// $ANTLR start "NATIONAL_CHAR_STRING_LIT"
	public final void mNATIONAL_CHAR_STRING_LIT() throws RecognitionException {
		try {
			int _type = NATIONAL_CHAR_STRING_LIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:130:5: ( ( 'N' | 'n' ) '\\'' ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )* '\\'' )
			// PLSQLLexer.g:130:10: ( 'N' | 'n' ) '\\'' ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )* '\\''
			{
			if ( input.LA(1)=='N'||input.LA(1)=='n' ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			match('\''); 
			// PLSQLLexer.g:130:27: ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )*
			loop2:
			while (true) {
				int alt2=4;
				int LA2_0 = input.LA(1);
				if ( (LA2_0=='\'') ) {
					int LA2_1 = input.LA(2);
					if ( (LA2_1=='\'') ) {
						alt2=2;
					}

				}
				else if ( ((LA2_0 >= '\u0000' && LA2_0 <= '\t')||(LA2_0 >= '\u000B' && LA2_0 <= '\f')||(LA2_0 >= '\u000E' && LA2_0 <= '&')||(LA2_0 >= '(' && LA2_0 <= '\uFFFF')) ) {
					alt2=1;
				}
				else if ( (LA2_0=='\n'||LA2_0=='\r') ) {
					alt2=3;
				}

				switch (alt2) {
				case 1 :
					// PLSQLLexer.g:130:51: ~ ( '\\'' | '\\r' | '\\n' )
					{
					if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '\uFFFF') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;
				case 2 :
					// PLSQLLexer.g:130:76: '\\'' '\\''
					{
					match('\''); 
					match('\''); 
					}
					break;
				case 3 :
					// PLSQLLexer.g:130:88: NEWLINE
					{
					mNEWLINE(); 

					}
					break;

				default :
					break loop2;
				}
			}

			match('\''); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NATIONAL_CHAR_STRING_LIT"

	// $ANTLR start "BIT_STRING_LIT"
	public final void mBIT_STRING_LIT() throws RecognitionException {
		try {
			int _type = BIT_STRING_LIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:137:5: ( ( 'B' | 'b' ) ( '\\'' ( '0' | '1' )* '\\'' ( SEPARATOR )? )+ )
			// PLSQLLexer.g:137:10: ( 'B' | 'b' ) ( '\\'' ( '0' | '1' )* '\\'' ( SEPARATOR )? )+
			{
			if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PLSQLLexer.g:137:22: ( '\\'' ( '0' | '1' )* '\\'' ( SEPARATOR )? )+
			int cnt5=0;
			loop5:
			while (true) {
				int alt5=2;
				int LA5_0 = input.LA(1);
				if ( (LA5_0=='\'') ) {
					alt5=1;
				}

				switch (alt5) {
				case 1 :
					// PLSQLLexer.g:137:23: '\\'' ( '0' | '1' )* '\\'' ( SEPARATOR )?
					{
					match('\''); 
					// PLSQLLexer.g:137:28: ( '0' | '1' )*
					loop3:
					while (true) {
						int alt3=2;
						int LA3_0 = input.LA(1);
						if ( ((LA3_0 >= '0' && LA3_0 <= '1')) ) {
							alt3=1;
						}

						switch (alt3) {
						case 1 :
							// PLSQLLexer.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '1') ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							break loop3;
						}
					}

					match('\''); 
					// PLSQLLexer.g:137:46: ( SEPARATOR )?
					int alt4=2;
					int LA4_0 = input.LA(1);
					if ( ((LA4_0 >= '\t' && LA4_0 <= '\n')||LA4_0=='\r'||LA4_0==' '||LA4_0=='-'||LA4_0=='/') ) {
						alt4=1;
					}
					switch (alt4) {
						case 1 :
							// PLSQLLexer.g:137:46: SEPARATOR
							{
							mSEPARATOR(); 

							}
							break;

					}

					}
					break;

				default :
					if ( cnt5 >= 1 ) break loop5;
					EarlyExitException eee = new EarlyExitException(5, input);
					throw eee;
				}
				cnt5++;
			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BIT_STRING_LIT"

	// $ANTLR start "HEX_STRING_LIT"
	public final void mHEX_STRING_LIT() throws RecognitionException {
		try {
			int _type = HEX_STRING_LIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:145:5: ( ( 'X' | 'x' ) ( '\\'' ( 'a' .. 'f' | 'A' .. 'F' | '0' .. '9' )* '\\'' ( SEPARATOR )? )+ )
			// PLSQLLexer.g:145:10: ( 'X' | 'x' ) ( '\\'' ( 'a' .. 'f' | 'A' .. 'F' | '0' .. '9' )* '\\'' ( SEPARATOR )? )+
			{
			if ( input.LA(1)=='X'||input.LA(1)=='x' ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PLSQLLexer.g:145:22: ( '\\'' ( 'a' .. 'f' | 'A' .. 'F' | '0' .. '9' )* '\\'' ( SEPARATOR )? )+
			int cnt8=0;
			loop8:
			while (true) {
				int alt8=2;
				int LA8_0 = input.LA(1);
				if ( (LA8_0=='\'') ) {
					alt8=1;
				}

				switch (alt8) {
				case 1 :
					// PLSQLLexer.g:145:23: '\\'' ( 'a' .. 'f' | 'A' .. 'F' | '0' .. '9' )* '\\'' ( SEPARATOR )?
					{
					match('\''); 
					// PLSQLLexer.g:145:28: ( 'a' .. 'f' | 'A' .. 'F' | '0' .. '9' )*
					loop6:
					while (true) {
						int alt6=2;
						int LA6_0 = input.LA(1);
						if ( ((LA6_0 >= '0' && LA6_0 <= '9')||(LA6_0 >= 'A' && LA6_0 <= 'F')||(LA6_0 >= 'a' && LA6_0 <= 'f')) ) {
							alt6=1;
						}

						switch (alt6) {
						case 1 :
							// PLSQLLexer.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'F')||(input.LA(1) >= 'a' && input.LA(1) <= 'f') ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							break loop6;
						}
					}

					match('\''); 
					// PLSQLLexer.g:145:67: ( SEPARATOR )?
					int alt7=2;
					int LA7_0 = input.LA(1);
					if ( ((LA7_0 >= '\t' && LA7_0 <= '\n')||LA7_0=='\r'||LA7_0==' '||LA7_0=='-'||LA7_0=='/') ) {
						alt7=1;
					}
					switch (alt7) {
						case 1 :
							// PLSQLLexer.g:145:67: SEPARATOR
							{
							mSEPARATOR(); 

							}
							break;

					}

					}
					break;

				default :
					if ( cnt8 >= 1 ) break loop8;
					EarlyExitException eee = new EarlyExitException(8, input);
					throw eee;
				}
				cnt8++;
			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "HEX_STRING_LIT"

	// $ANTLR start "PERIOD"
	public final void mPERIOD() throws RecognitionException {
		try {
			int _type = PERIOD;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:150:5: ( '.' )
			// PLSQLLexer.g:150:10: '.'
			{
			match('.'); 
			    if ((char) input.LA(1) == '.') {
			            input.consume();
			            _type = DOUBLE_PERIOD;
			        }
			    
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PERIOD"

	// $ANTLR start "EXACT_NUM_LIT"
	public final void mEXACT_NUM_LIT() throws RecognitionException {
		try {
			int _type = EXACT_NUM_LIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:164:5: ( ( UNSIGNED_INTEGER ( '.' ( UNSIGNED_INTEGER )? |) ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? | '.' UNSIGNED_INTEGER ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? ) ( 'D' | 'd' | 'f' | 'F' )? )
			// PLSQLLexer.g:164:7: ( UNSIGNED_INTEGER ( '.' ( UNSIGNED_INTEGER )? |) ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? | '.' UNSIGNED_INTEGER ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? ) ( 'D' | 'd' | 'f' | 'F' )?
			{
			// PLSQLLexer.g:164:7: ( UNSIGNED_INTEGER ( '.' ( UNSIGNED_INTEGER )? |) ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? | '.' UNSIGNED_INTEGER ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )? )
			int alt15=2;
			int LA15_0 = input.LA(1);
			if ( ((LA15_0 >= '0' && LA15_0 <= '9')) ) {
				alt15=1;
			}
			else if ( (LA15_0=='.') ) {
				alt15=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 15, 0, input);
				throw nvae;
			}

			switch (alt15) {
				case 1 :
					// PLSQLLexer.g:165:13: UNSIGNED_INTEGER ( '.' ( UNSIGNED_INTEGER )? |) ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )?
					{
					mUNSIGNED_INTEGER(); 

					// PLSQLLexer.g:166:13: ( '.' ( UNSIGNED_INTEGER )? |)
					int alt10=2;
					int LA10_0 = input.LA(1);
					if ( (LA10_0=='.') ) {
						alt10=1;
					}

					else {
						alt10=2;
					}

					switch (alt10) {
						case 1 :
							// PLSQLLexer.g:166:15: '.' ( UNSIGNED_INTEGER )?
							{
							match('.'); 
							// PLSQLLexer.g:166:19: ( UNSIGNED_INTEGER )?
							int alt9=2;
							int LA9_0 = input.LA(1);
							if ( ((LA9_0 >= '0' && LA9_0 <= '9')) ) {
								alt9=1;
							}
							switch (alt9) {
								case 1 :
									// PLSQLLexer.g:166:19: UNSIGNED_INTEGER
									{
									mUNSIGNED_INTEGER(); 

									}
									break;

							}

							}
							break;
						case 2 :
							// PLSQLLexer.g:167:18: 
							{
							_type = UNSIGNED_INTEGER;
							}
							break;

					}

					// PLSQLLexer.g:168:15: ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )?
					int alt12=2;
					int LA12_0 = input.LA(1);
					if ( (LA12_0=='E'||LA12_0=='e') ) {
						alt12=1;
					}
					switch (alt12) {
						case 1 :
							// PLSQLLexer.g:168:17: ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER
							{
							if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							// PLSQLLexer.g:168:29: ( '+' | '-' )?
							int alt11=2;
							int LA11_0 = input.LA(1);
							if ( (LA11_0=='+'||LA11_0=='-') ) {
								alt11=1;
							}
							switch (alt11) {
								case 1 :
									// PLSQLLexer.g:
									{
									if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
										input.consume();
									}
									else {
										MismatchedSetException mse = new MismatchedSetException(null,input);
										recover(mse);
										throw mse;
									}
									}
									break;

							}

							mUNSIGNED_INTEGER(); 

							_type = APPROXIMATE_NUM_LIT;
							}
							break;

					}

					}
					break;
				case 2 :
					// PLSQLLexer.g:169:10: '.' UNSIGNED_INTEGER ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )?
					{
					match('.'); 
					mUNSIGNED_INTEGER(); 

					// PLSQLLexer.g:169:31: ( ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER )?
					int alt14=2;
					int LA14_0 = input.LA(1);
					if ( (LA14_0=='E'||LA14_0=='e') ) {
						alt14=1;
					}
					switch (alt14) {
						case 1 :
							// PLSQLLexer.g:169:33: ( 'E' | 'e' ) ( '+' | '-' )? UNSIGNED_INTEGER
							{
							if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							// PLSQLLexer.g:169:45: ( '+' | '-' )?
							int alt13=2;
							int LA13_0 = input.LA(1);
							if ( (LA13_0=='+'||LA13_0=='-') ) {
								alt13=1;
							}
							switch (alt13) {
								case 1 :
									// PLSQLLexer.g:
									{
									if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
										input.consume();
									}
									else {
										MismatchedSetException mse = new MismatchedSetException(null,input);
										recover(mse);
										throw mse;
									}
									}
									break;

							}

							mUNSIGNED_INTEGER(); 

							_type = APPROXIMATE_NUM_LIT;
							}
							break;

					}

					}
					break;

			}

			// PLSQLLexer.g:171:5: ( 'D' | 'd' | 'f' | 'F' )?
			int alt16=2;
			int LA16_0 = input.LA(1);
			if ( (LA16_0=='D'||LA16_0=='F'||LA16_0=='d'||LA16_0=='f') ) {
				alt16=1;
			}
			switch (alt16) {
				case 1 :
					// PLSQLLexer.g:
					{
					if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='d'||input.LA(1)=='f' ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EXACT_NUM_LIT"

	// $ANTLR start "CHAR_STRING"
	public final void mCHAR_STRING() throws RecognitionException {
		try {
			int _type = CHAR_STRING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:178:5: ( '\\'' ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )* '\\'' )
			// PLSQLLexer.g:178:10: '\\'' ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )* '\\''
			{
			match('\''); 
			// PLSQLLexer.g:178:15: ( options {greedy=true; } :~ ( '\\'' | '\\r' | '\\n' ) | '\\'' '\\'' | NEWLINE )*
			loop17:
			while (true) {
				int alt17=4;
				int LA17_0 = input.LA(1);
				if ( (LA17_0=='\'') ) {
					int LA17_1 = input.LA(2);
					if ( (LA17_1=='\'') ) {
						alt17=2;
					}

				}
				else if ( ((LA17_0 >= '\u0000' && LA17_0 <= '\t')||(LA17_0 >= '\u000B' && LA17_0 <= '\f')||(LA17_0 >= '\u000E' && LA17_0 <= '&')||(LA17_0 >= '(' && LA17_0 <= '\uFFFF')) ) {
					alt17=1;
				}
				else if ( (LA17_0=='\n'||LA17_0=='\r') ) {
					alt17=3;
				}

				switch (alt17) {
				case 1 :
					// PLSQLLexer.g:178:39: ~ ( '\\'' | '\\r' | '\\n' )
					{
					if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '&')||(input.LA(1) >= '(' && input.LA(1) <= '\uFFFF') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;
				case 2 :
					// PLSQLLexer.g:178:63: '\\'' '\\''
					{
					match('\''); 
					match('\''); 
					}
					break;
				case 3 :
					// PLSQLLexer.g:178:75: NEWLINE
					{
					mNEWLINE(); 

					}
					break;

				default :
					break loop17;
				}
			}

			match('\''); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CHAR_STRING"

	// $ANTLR start "CHAR_STRING_PERL"
	public final void mCHAR_STRING_PERL() throws RecognitionException {
		try {
			int _type = CHAR_STRING_PERL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:183:21: ( ( 'q' | 'Q' ) ( QS_ANGLE | QS_BRACE | QS_BRACK | QS_PAREN | QS_OTHER ) )
			// PLSQLLexer.g:183:23: ( 'q' | 'Q' ) ( QS_ANGLE | QS_BRACE | QS_BRACK | QS_PAREN | QS_OTHER )
			{
			if ( input.LA(1)=='Q'||input.LA(1)=='q' ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PLSQLLexer.g:183:33: ( QS_ANGLE | QS_BRACE | QS_BRACK | QS_PAREN | QS_OTHER )
			int alt18=5;
			int LA18_0 = input.LA(1);
			if ( (LA18_0=='\'') ) {
				int LA18_1 = input.LA(2);
				if ( (LA18_1=='<') ) {
					alt18=1;
				}
				else if ( (LA18_1=='{') ) {
					alt18=2;
				}
				else if ( (LA18_1=='[') ) {
					alt18=3;
				}
				else if ( (LA18_1=='(') ) {
					alt18=4;
				}
				else if ( ((LA18_1 >= '\u0000' && LA18_1 <= '\b')||(LA18_1 >= '\u000B' && LA18_1 <= '\f')||(LA18_1 >= '\u000E' && LA18_1 <= '\u001F')||(LA18_1 >= '!' && LA18_1 <= '\'')||(LA18_1 >= ')' && LA18_1 <= ';')||(LA18_1 >= '=' && LA18_1 <= 'Z')||(LA18_1 >= '\\' && LA18_1 <= 'z')||(LA18_1 >= '|' && LA18_1 <= '\uFFFF')) ) {
					alt18=5;
				}

				else {
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 18, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 18, 0, input);
				throw nvae;
			}

			switch (alt18) {
				case 1 :
					// PLSQLLexer.g:183:35: QS_ANGLE
					{
					mQS_ANGLE(); 

					}
					break;
				case 2 :
					// PLSQLLexer.g:183:46: QS_BRACE
					{
					mQS_BRACE(); 

					}
					break;
				case 3 :
					// PLSQLLexer.g:183:57: QS_BRACK
					{
					mQS_BRACK(); 

					}
					break;
				case 4 :
					// PLSQLLexer.g:183:68: QS_PAREN
					{
					mQS_PAREN(); 

					}
					break;
				case 5 :
					// PLSQLLexer.g:183:79: QS_OTHER
					{
					mQS_OTHER(); 

					}
					break;

			}

			_type = CHAR_STRING;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CHAR_STRING_PERL"

	// $ANTLR start "QUOTE"
	public final void mQUOTE() throws RecognitionException {
		try {
			// PLSQLLexer.g:184:21: ( '\\'' )
			// PLSQLLexer.g:184:23: '\\''
			{
			match('\''); 
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QUOTE"

	// $ANTLR start "QS_ANGLE"
	public final void mQS_ANGLE() throws RecognitionException {
		try {
			// PLSQLLexer.g:185:21: ( QUOTE '<' ( options {greedy=false; } : . )* '>' QUOTE )
			// PLSQLLexer.g:185:23: QUOTE '<' ( options {greedy=false; } : . )* '>' QUOTE
			{
			mQUOTE(); 

			match('<'); 
			// PLSQLLexer.g:185:33: ( options {greedy=false; } : . )*
			loop19:
			while (true) {
				int alt19=2;
				int LA19_0 = input.LA(1);
				if ( (LA19_0=='>') ) {
					int LA19_1 = input.LA(2);
					if ( (LA19_1=='\'') ) {
						alt19=2;
					}
					else if ( ((LA19_1 >= '\u0000' && LA19_1 <= '&')||(LA19_1 >= '(' && LA19_1 <= '\uFFFF')) ) {
						alt19=1;
					}

				}
				else if ( ((LA19_0 >= '\u0000' && LA19_0 <= '=')||(LA19_0 >= '?' && LA19_0 <= '\uFFFF')) ) {
					alt19=1;
				}

				switch (alt19) {
				case 1 :
					// PLSQLLexer.g:185:61: .
					{
					matchAny(); 
					}
					break;

				default :
					break loop19;
				}
			}

			match('>'); 
			mQUOTE(); 

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_ANGLE"

	// $ANTLR start "QS_BRACE"
	public final void mQS_BRACE() throws RecognitionException {
		try {
			// PLSQLLexer.g:186:21: ( QUOTE '{' ( options {greedy=false; } : . )* '}' QUOTE )
			// PLSQLLexer.g:186:23: QUOTE '{' ( options {greedy=false; } : . )* '}' QUOTE
			{
			mQUOTE(); 

			match('{'); 
			// PLSQLLexer.g:186:33: ( options {greedy=false; } : . )*
			loop20:
			while (true) {
				int alt20=2;
				int LA20_0 = input.LA(1);
				if ( (LA20_0=='}') ) {
					int LA20_1 = input.LA(2);
					if ( (LA20_1=='\'') ) {
						alt20=2;
					}
					else if ( ((LA20_1 >= '\u0000' && LA20_1 <= '&')||(LA20_1 >= '(' && LA20_1 <= '\uFFFF')) ) {
						alt20=1;
					}

				}
				else if ( ((LA20_0 >= '\u0000' && LA20_0 <= '|')||(LA20_0 >= '~' && LA20_0 <= '\uFFFF')) ) {
					alt20=1;
				}

				switch (alt20) {
				case 1 :
					// PLSQLLexer.g:186:61: .
					{
					matchAny(); 
					}
					break;

				default :
					break loop20;
				}
			}

			match('}'); 
			mQUOTE(); 

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_BRACE"

	// $ANTLR start "QS_BRACK"
	public final void mQS_BRACK() throws RecognitionException {
		try {
			// PLSQLLexer.g:187:21: ( QUOTE '[' ( options {greedy=false; } : . )* ']' QUOTE )
			// PLSQLLexer.g:187:23: QUOTE '[' ( options {greedy=false; } : . )* ']' QUOTE
			{
			mQUOTE(); 

			match('['); 
			// PLSQLLexer.g:187:33: ( options {greedy=false; } : . )*
			loop21:
			while (true) {
				int alt21=2;
				int LA21_0 = input.LA(1);
				if ( (LA21_0==']') ) {
					int LA21_1 = input.LA(2);
					if ( (LA21_1=='\'') ) {
						alt21=2;
					}
					else if ( ((LA21_1 >= '\u0000' && LA21_1 <= '&')||(LA21_1 >= '(' && LA21_1 <= '\uFFFF')) ) {
						alt21=1;
					}

				}
				else if ( ((LA21_0 >= '\u0000' && LA21_0 <= '\\')||(LA21_0 >= '^' && LA21_0 <= '\uFFFF')) ) {
					alt21=1;
				}

				switch (alt21) {
				case 1 :
					// PLSQLLexer.g:187:61: .
					{
					matchAny(); 
					}
					break;

				default :
					break loop21;
				}
			}

			match(']'); 
			mQUOTE(); 

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_BRACK"

	// $ANTLR start "QS_PAREN"
	public final void mQS_PAREN() throws RecognitionException {
		try {
			// PLSQLLexer.g:188:21: ( QUOTE '(' ( options {greedy=false; } : . )* ')' QUOTE )
			// PLSQLLexer.g:188:23: QUOTE '(' ( options {greedy=false; } : . )* ')' QUOTE
			{
			mQUOTE(); 

			match('('); 
			// PLSQLLexer.g:188:33: ( options {greedy=false; } : . )*
			loop22:
			while (true) {
				int alt22=2;
				int LA22_0 = input.LA(1);
				if ( (LA22_0==')') ) {
					int LA22_1 = input.LA(2);
					if ( (LA22_1=='\'') ) {
						alt22=2;
					}
					else if ( ((LA22_1 >= '\u0000' && LA22_1 <= '&')||(LA22_1 >= '(' && LA22_1 <= '\uFFFF')) ) {
						alt22=1;
					}

				}
				else if ( ((LA22_0 >= '\u0000' && LA22_0 <= '(')||(LA22_0 >= '*' && LA22_0 <= '\uFFFF')) ) {
					alt22=1;
				}

				switch (alt22) {
				case 1 :
					// PLSQLLexer.g:188:61: .
					{
					matchAny(); 
					}
					break;

				default :
					break loop22;
				}
			}

			match(')'); 
			mQUOTE(); 

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_PAREN"

	// $ANTLR start "QS_OTHER_CH"
	public final void mQS_OTHER_CH() throws RecognitionException {
		try {
			// PLSQLLexer.g:190:21: (~ ( '<' | '{' | '[' | '(' | ' ' | '\\t' | '\\n' | '\\r' ) )
			// PLSQLLexer.g:
			{
			if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\b')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\u001F')||(input.LA(1) >= '!' && input.LA(1) <= '\'')||(input.LA(1) >= ')' && input.LA(1) <= ';')||(input.LA(1) >= '=' && input.LA(1) <= 'Z')||(input.LA(1) >= '\\' && input.LA(1) <= 'z')||(input.LA(1) >= '|' && input.LA(1) <= '\uFFFF') ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_OTHER_CH"

	// $ANTLR start "QS_OTHER"
	public final void mQS_OTHER() throws RecognitionException {
		try {
			CommonToken delimiter=null;

			// PLSQLLexer.g:200:3: ( QUOTE delimiter= QS_OTHER_CH ({...}? => . )* ({...}? => . ) QUOTE )
			// PLSQLLexer.g:201:3: QUOTE delimiter= QS_OTHER_CH ({...}? => . )* ({...}? => . ) QUOTE
			{
			mQUOTE(); 

			int delimiterStart869 = getCharIndex();
			int delimiterStartLine869 = getLine();
			int delimiterStartCharPos869 = getCharPositionInLine();
			mQS_OTHER_CH(); 
			delimiter = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, delimiterStart869, getCharIndex()-1);
			delimiter.setLine(delimiterStartLine869);
			delimiter.setCharPositionInLine(delimiterStartCharPos869);

			// PLSQLLexer.g:203:5: ({...}? => . )*
			loop23:
			while (true) {
				int alt23=2;
				int LA23_0 = input.LA(1);
				if ( ((LA23_0 >= '\u0000' && LA23_0 <= '\uFFFF')) && ((( input.LT(1) != (delimiter!=null?delimiter.getText():null).charAt(0) || ( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) != '\'') )||( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) == '\'' )))) {
					int LA23_1 = input.LA(2);
					if ( (LA23_1=='\'') && ((( input.LT(1) != (delimiter!=null?delimiter.getText():null).charAt(0) || ( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) != '\'') )||( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) == '\'' )))) {
						int LA23_2 = input.LA(3);
						if ( ((LA23_2 >= '\u0000' && LA23_2 <= '\uFFFF')) && (( input.LT(1) != (delimiter!=null?delimiter.getText():null).charAt(0) || ( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) != '\'') ))) {
							alt23=1;
						}

					}
					else if ( ((LA23_1 >= '\u0000' && LA23_1 <= '&')||(LA23_1 >= '(' && LA23_1 <= '\uFFFF')) && (( input.LT(1) != (delimiter!=null?delimiter.getText():null).charAt(0) || ( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) != '\'') ))) {
						alt23=1;
					}

				}

				switch (alt23) {
				case 1 :
					// PLSQLLexer.g:203:7: {...}? => .
					{
					if ( !(( input.LT(1) != (delimiter!=null?delimiter.getText():null).charAt(0) || ( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) != '\'') )) ) {
						throw new FailedPredicateException(input, "QS_OTHER", " input.LT(1) != $delimiter.text.charAt(0) || ( input.LT(1) == $delimiter.text.charAt(0) && input.LT(2) != '\\'') ");
					}
					matchAny(); 
					}
					break;

				default :
					break loop23;
				}
			}

			// PLSQLLexer.g:204:5: ({...}? => . )
			// PLSQLLexer.g:204:7: {...}? => .
			{
			if ( !(( input.LT(1) == (delimiter!=null?delimiter.getText():null).charAt(0) && input.LT(2) == '\'' )) ) {
				throw new FailedPredicateException(input, "QS_OTHER", " input.LT(1) == $delimiter.text.charAt(0) && input.LT(2) == '\\'' ");
			}
			matchAny(); 
			}

			mQUOTE(); 

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QS_OTHER"

	// $ANTLR start "DELIMITED_ID"
	public final void mDELIMITED_ID() throws RecognitionException {
		try {
			int _type = DELIMITED_ID;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:214:5: ( '\"' (~ ( '\"' | '\\r' | '\\n' ) | '\"' '\"' )+ '\"' )
			// PLSQLLexer.g:214:10: '\"' (~ ( '\"' | '\\r' | '\\n' ) | '\"' '\"' )+ '\"'
			{
			match('\"'); 
			// PLSQLLexer.g:214:14: (~ ( '\"' | '\\r' | '\\n' ) | '\"' '\"' )+
			int cnt24=0;
			loop24:
			while (true) {
				int alt24=3;
				int LA24_0 = input.LA(1);
				if ( (LA24_0=='\"') ) {
					int LA24_1 = input.LA(2);
					if ( (LA24_1=='\"') ) {
						alt24=2;
					}

				}
				else if ( ((LA24_0 >= '\u0000' && LA24_0 <= '\t')||(LA24_0 >= '\u000B' && LA24_0 <= '\f')||(LA24_0 >= '\u000E' && LA24_0 <= '!')||(LA24_0 >= '#' && LA24_0 <= '\uFFFF')) ) {
					alt24=1;
				}

				switch (alt24) {
				case 1 :
					// PLSQLLexer.g:214:15: ~ ( '\"' | '\\r' | '\\n' )
					{
					if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '!')||(input.LA(1) >= '#' && input.LA(1) <= '\uFFFF') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;
				case 2 :
					// PLSQLLexer.g:214:38: '\"' '\"'
					{
					match('\"'); 
					match('\"'); 
					}
					break;

				default :
					if ( cnt24 >= 1 ) break loop24;
					EarlyExitException eee = new EarlyExitException(24, input);
					throw eee;
				}
				cnt24++;
			}

			match('\"'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DELIMITED_ID"

	// $ANTLR start "PERCENT"
	public final void mPERCENT() throws RecognitionException {
		try {
			int _type = PERCENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:220:5: ( '%' )
			// PLSQLLexer.g:220:10: '%'
			{
			match('%'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PERCENT"

	// $ANTLR start "AMPERSAND"
	public final void mAMPERSAND() throws RecognitionException {
		try {
			int _type = AMPERSAND;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:224:5: ( '&' )
			// PLSQLLexer.g:224:10: '&'
			{
			match('&'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "AMPERSAND"

	// $ANTLR start "LEFT_PAREN"
	public final void mLEFT_PAREN() throws RecognitionException {
		try {
			int _type = LEFT_PAREN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:228:5: ( '(' )
			// PLSQLLexer.g:228:10: '('
			{
			match('('); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LEFT_PAREN"

	// $ANTLR start "RIGHT_PAREN"
	public final void mRIGHT_PAREN() throws RecognitionException {
		try {
			int _type = RIGHT_PAREN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:232:5: ( ')' )
			// PLSQLLexer.g:232:10: ')'
			{
			match(')'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RIGHT_PAREN"

	// $ANTLR start "DOUBLE_ASTERISK"
	public final void mDOUBLE_ASTERISK() throws RecognitionException {
		try {
			int _type = DOUBLE_ASTERISK;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:237:5: ( '**' )
			// PLSQLLexer.g:237:10: '**'
			{
			match("**"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOUBLE_ASTERISK"

	// $ANTLR start "ASTERISK"
	public final void mASTERISK() throws RecognitionException {
		try {
			int _type = ASTERISK;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:241:5: ( '*' )
			// PLSQLLexer.g:241:10: '*'
			{
			match('*'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ASTERISK"

	// $ANTLR start "PLUS_SIGN"
	public final void mPLUS_SIGN() throws RecognitionException {
		try {
			int _type = PLUS_SIGN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:245:5: ( '+' )
			// PLSQLLexer.g:245:10: '+'
			{
			match('+'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLUS_SIGN"

	// $ANTLR start "COMMA"
	public final void mCOMMA() throws RecognitionException {
		try {
			int _type = COMMA;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:249:5: ( ',' )
			// PLSQLLexer.g:249:10: ','
			{
			match(','); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COMMA"

	// $ANTLR start "SOLIDUS"
	public final void mSOLIDUS() throws RecognitionException {
		try {
			int _type = SOLIDUS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:253:5: ( '/' )
			// PLSQLLexer.g:253:10: '/'
			{
			match('/'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SOLIDUS"

	// $ANTLR start "AT_SIGN"
	public final void mAT_SIGN() throws RecognitionException {
		try {
			int _type = AT_SIGN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:257:5: ( '@' )
			// PLSQLLexer.g:257:10: '@'
			{
			match('@'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "AT_SIGN"

	// $ANTLR start "ASSIGN_OP"
	public final void mASSIGN_OP() throws RecognitionException {
		try {
			int _type = ASSIGN_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:261:5: ( ':=' )
			// PLSQLLexer.g:261:10: ':='
			{
			match(":="); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ASSIGN_OP"

	// $ANTLR start "BINDVAR"
	public final void mBINDVAR() throws RecognitionException {
		try {
			int _type = BINDVAR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:266:5: ( COLON SIMPLE_LETTER ( SIMPLE_LETTER | '0' .. '9' | '_' )* | COLON DELIMITED_ID | COLON UNSIGNED_INTEGER | QUESTION_MARK )
			int alt26=4;
			int LA26_0 = input.LA(1);
			if ( (LA26_0==':') ) {
				switch ( input.LA(2) ) {
				case 'A':
				case 'B':
				case 'C':
				case 'D':
				case 'E':
				case 'F':
				case 'G':
				case 'H':
				case 'I':
				case 'J':
				case 'K':
				case 'L':
				case 'M':
				case 'N':
				case 'O':
				case 'P':
				case 'Q':
				case 'R':
				case 'S':
				case 'T':
				case 'U':
				case 'V':
				case 'W':
				case 'X':
				case 'Y':
				case 'Z':
				case 'a':
				case 'b':
				case 'c':
				case 'd':
				case 'e':
				case 'f':
				case 'g':
				case 'h':
				case 'i':
				case 'j':
				case 'k':
				case 'l':
				case 'm':
				case 'n':
				case 'o':
				case 'p':
				case 'q':
				case 'r':
				case 's':
				case 't':
				case 'u':
				case 'v':
				case 'w':
				case 'x':
				case 'y':
				case 'z':
					{
					alt26=1;
					}
					break;
				case '\"':
					{
					alt26=2;
					}
					break;
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					{
					alt26=3;
					}
					break;
				default:
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 26, 1, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}
			}
			else if ( (LA26_0=='?') ) {
				alt26=4;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 26, 0, input);
				throw nvae;
			}

			switch (alt26) {
				case 1 :
					// PLSQLLexer.g:266:10: COLON SIMPLE_LETTER ( SIMPLE_LETTER | '0' .. '9' | '_' )*
					{
					mCOLON(); 

					mSIMPLE_LETTER(); 

					// PLSQLLexer.g:266:31: ( SIMPLE_LETTER | '0' .. '9' | '_' )*
					loop25:
					while (true) {
						int alt25=2;
						int LA25_0 = input.LA(1);
						if ( ((LA25_0 >= '0' && LA25_0 <= '9')||(LA25_0 >= 'A' && LA25_0 <= 'Z')||LA25_0=='_'||(LA25_0 >= 'a' && LA25_0 <= 'z')) ) {
							alt25=1;
						}

						switch (alt25) {
						case 1 :
							// PLSQLLexer.g:
							{
							if ( (input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							break loop25;
						}
					}

					}
					break;
				case 2 :
					// PLSQLLexer.g:267:10: COLON DELIMITED_ID
					{
					mCOLON(); 

					mDELIMITED_ID(); 

					}
					break;
				case 3 :
					// PLSQLLexer.g:268:10: COLON UNSIGNED_INTEGER
					{
					mCOLON(); 

					mUNSIGNED_INTEGER(); 

					}
					break;
				case 4 :
					// PLSQLLexer.g:269:10: QUESTION_MARK
					{
					mQUESTION_MARK(); 

					}
					break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "BINDVAR"

	// $ANTLR start "COLON"
	public final void mCOLON() throws RecognitionException {
		try {
			int _type = COLON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:273:5: ( ':' )
			// PLSQLLexer.g:273:10: ':'
			{
			match(':'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COLON"

	// $ANTLR start "SEMICOLON"
	public final void mSEMICOLON() throws RecognitionException {
		try {
			int _type = SEMICOLON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:277:5: ( ';' )
			// PLSQLLexer.g:277:10: ';'
			{
			match(';'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SEMICOLON"

	// $ANTLR start "LESS_THAN_OR_EQUALS_OP"
	public final void mLESS_THAN_OR_EQUALS_OP() throws RecognitionException {
		try {
			int _type = LESS_THAN_OR_EQUALS_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:281:5: ( '<=' )
			// PLSQLLexer.g:281:10: '<='
			{
			match("<="); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LESS_THAN_OR_EQUALS_OP"

	// $ANTLR start "LESS_THAN_OP"
	public final void mLESS_THAN_OP() throws RecognitionException {
		try {
			int _type = LESS_THAN_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:285:5: ( '<' )
			// PLSQLLexer.g:285:10: '<'
			{
			match('<'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LESS_THAN_OP"

	// $ANTLR start "GREATER_THAN_OR_EQUALS_OP"
	public final void mGREATER_THAN_OR_EQUALS_OP() throws RecognitionException {
		try {
			int _type = GREATER_THAN_OR_EQUALS_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:289:5: ( '>=' )
			// PLSQLLexer.g:289:10: '>='
			{
			match(">="); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "GREATER_THAN_OR_EQUALS_OP"

	// $ANTLR start "NOT_EQUAL_OP"
	public final void mNOT_EQUAL_OP() throws RecognitionException {
		try {
			int _type = NOT_EQUAL_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:293:5: ( '!=' | '<>' | '^=' | '~=' )
			int alt27=4;
			switch ( input.LA(1) ) {
			case '!':
				{
				alt27=1;
				}
				break;
			case '<':
				{
				alt27=2;
				}
				break;
			case '^':
				{
				alt27=3;
				}
				break;
			case '~':
				{
				alt27=4;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 27, 0, input);
				throw nvae;
			}
			switch (alt27) {
				case 1 :
					// PLSQLLexer.g:293:10: '!='
					{
					match("!="); 

					}
					break;
				case 2 :
					// PLSQLLexer.g:294:10: '<>'
					{
					match("<>"); 

					}
					break;
				case 3 :
					// PLSQLLexer.g:295:10: '^='
					{
					match("^="); 

					}
					break;
				case 4 :
					// PLSQLLexer.g:296:10: '~='
					{
					match("~="); 

					}
					break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NOT_EQUAL_OP"

	// $ANTLR start "CARRET_OPERATOR_PART"
	public final void mCARRET_OPERATOR_PART() throws RecognitionException {
		try {
			int _type = CARRET_OPERATOR_PART;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:299:5: ( '^' )
			// PLSQLLexer.g:299:10: '^'
			{
			match('^'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CARRET_OPERATOR_PART"

	// $ANTLR start "TILDE_OPERATOR_PART"
	public final void mTILDE_OPERATOR_PART() throws RecognitionException {
		try {
			int _type = TILDE_OPERATOR_PART;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:303:5: ( '~' )
			// PLSQLLexer.g:303:10: '~'
			{
			match('~'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "TILDE_OPERATOR_PART"

	// $ANTLR start "EXCLAMATION_OPERATOR_PART"
	public final void mEXCLAMATION_OPERATOR_PART() throws RecognitionException {
		try {
			int _type = EXCLAMATION_OPERATOR_PART;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:307:5: ( '!' )
			// PLSQLLexer.g:307:10: '!'
			{
			match('!'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EXCLAMATION_OPERATOR_PART"

	// $ANTLR start "GREATER_THAN_OP"
	public final void mGREATER_THAN_OP() throws RecognitionException {
		try {
			int _type = GREATER_THAN_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:311:5: ( '>' )
			// PLSQLLexer.g:311:10: '>'
			{
			match('>'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "GREATER_THAN_OP"

	// $ANTLR start "QUESTION_MARK"
	public final void mQUESTION_MARK() throws RecognitionException {
		try {
			// PLSQLLexer.g:316:5: ( '?' )
			// PLSQLLexer.g:316:10: '?'
			{
			match('?'); 
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "QUESTION_MARK"

	// $ANTLR start "CONCATENATION_OP"
	public final void mCONCATENATION_OP() throws RecognitionException {
		try {
			int _type = CONCATENATION_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:321:5: ( '||' )
			// PLSQLLexer.g:321:10: '||'
			{
			match("||"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "CONCATENATION_OP"

	// $ANTLR start "VERTICAL_BAR"
	public final void mVERTICAL_BAR() throws RecognitionException {
		try {
			int _type = VERTICAL_BAR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:325:5: ( '|' )
			// PLSQLLexer.g:325:10: '|'
			{
			match('|'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "VERTICAL_BAR"

	// $ANTLR start "EQUALS_OP"
	public final void mEQUALS_OP() throws RecognitionException {
		try {
			int _type = EQUALS_OP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:329:5: ( '=' )
			// PLSQLLexer.g:329:10: '='
			{
			match('='); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "EQUALS_OP"

	// $ANTLR start "LEFT_BRACKET"
	public final void mLEFT_BRACKET() throws RecognitionException {
		try {
			int _type = LEFT_BRACKET;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:334:5: ( '[' )
			// PLSQLLexer.g:334:10: '['
			{
			match('['); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "LEFT_BRACKET"

	// $ANTLR start "RIGHT_BRACKET"
	public final void mRIGHT_BRACKET() throws RecognitionException {
		try {
			int _type = RIGHT_BRACKET;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:338:5: ( ']' )
			// PLSQLLexer.g:338:10: ']'
			{
			match(']'); 
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "RIGHT_BRACKET"

	// $ANTLR start "INTRODUCER"
	public final void mINTRODUCER() throws RecognitionException {
		try {
			int _type = INTRODUCER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:345:5: ( '_' ( SEPARATOR )? )
			// PLSQLLexer.g:345:10: '_' ( SEPARATOR )?
			{
			match('_'); 
			// PLSQLLexer.g:345:14: ( SEPARATOR )?
			int alt28=2;
			int LA28_0 = input.LA(1);
			if ( ((LA28_0 >= '\t' && LA28_0 <= '\n')||LA28_0=='\r'||LA28_0==' '||LA28_0=='-'||LA28_0=='/') ) {
				alt28=1;
			}
			switch (alt28) {
				case 1 :
					// PLSQLLexer.g:345:15: SEPARATOR
					{
					mSEPARATOR(); 

					_type = UNDERSCORE;
					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "INTRODUCER"

	// $ANTLR start "SEPARATOR"
	public final void mSEPARATOR() throws RecognitionException {
		try {
			int _type = SEPARATOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:351:5: ( '-' | COMMENT | ( SPACE | NEWLINE )+ )
			int alt30=3;
			switch ( input.LA(1) ) {
			case '-':
				{
				int LA30_1 = input.LA(2);
				if ( (LA30_1=='-') ) {
					alt30=2;
				}

				else {
					alt30=1;
				}

				}
				break;
			case '/':
				{
				alt30=2;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
				{
				alt30=3;
				}
				break;
			default:
				NoViableAltException nvae =
					new NoViableAltException("", 30, 0, input);
				throw nvae;
			}
			switch (alt30) {
				case 1 :
					// PLSQLLexer.g:351:10: '-'
					{
					match('-'); 
					_type = MINUS_SIGN;
					}
					break;
				case 2 :
					// PLSQLLexer.g:352:10: COMMENT
					{
					mCOMMENT(); 

					 _channel=HIDDEN; 
					}
					break;
				case 3 :
					// PLSQLLexer.g:353:10: ( SPACE | NEWLINE )+
					{
					// PLSQLLexer.g:353:10: ( SPACE | NEWLINE )+
					int cnt29=0;
					loop29:
					while (true) {
						int alt29=3;
						int LA29_0 = input.LA(1);
						if ( (LA29_0=='\t'||LA29_0==' ') ) {
							alt29=1;
						}
						else if ( (LA29_0=='\n'||LA29_0=='\r') ) {
							alt29=2;
						}

						switch (alt29) {
						case 1 :
							// PLSQLLexer.g:353:11: SPACE
							{
							mSPACE(); 

							}
							break;
						case 2 :
							// PLSQLLexer.g:353:19: NEWLINE
							{
							mNEWLINE(); 

							}
							break;

						default :
							if ( cnt29 >= 1 ) break loop29;
							EarlyExitException eee = new EarlyExitException(29, input);
							throw eee;
						}
						cnt29++;
					}

					 _channel=HIDDEN; 
					}
					break;

			}
			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SEPARATOR"

	// $ANTLR start "SIMPLE_LETTER"
	public final void mSIMPLE_LETTER() throws RecognitionException {
		try {
			// PLSQLLexer.g:361:5: ( 'a' .. 'z' | 'A' .. 'Z' )
			// PLSQLLexer.g:
			{
			if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SIMPLE_LETTER"

	// $ANTLR start "UNSIGNED_INTEGER"
	public final void mUNSIGNED_INTEGER() throws RecognitionException {
		try {
			// PLSQLLexer.g:370:5: ( ( '0' .. '9' )+ )
			// PLSQLLexer.g:370:10: ( '0' .. '9' )+
			{
			// PLSQLLexer.g:370:10: ( '0' .. '9' )+
			int cnt31=0;
			loop31:
			while (true) {
				int alt31=2;
				int LA31_0 = input.LA(1);
				if ( ((LA31_0 >= '0' && LA31_0 <= '9')) ) {
					alt31=1;
				}

				switch (alt31) {
				case 1 :
					// PLSQLLexer.g:
					{
					if ( (input.LA(1) >= '0' && input.LA(1) <= '9') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					if ( cnt31 >= 1 ) break loop31;
					EarlyExitException eee = new EarlyExitException(31, input);
					throw eee;
				}
				cnt31++;
			}

			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UNSIGNED_INTEGER"

	// $ANTLR start "COMMENT"
	public final void mCOMMENT() throws RecognitionException {
		try {
			// PLSQLLexer.g:377:5: ( '--' (~ ( '\\r' | '\\n' ) )* ( NEWLINE | EOF ) | '/*' ( options {greedy=false; } : . )* '*/' )
			int alt35=2;
			int LA35_0 = input.LA(1);
			if ( (LA35_0=='-') ) {
				alt35=1;
			}
			else if ( (LA35_0=='/') ) {
				alt35=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 35, 0, input);
				throw nvae;
			}

			switch (alt35) {
				case 1 :
					// PLSQLLexer.g:377:10: '--' (~ ( '\\r' | '\\n' ) )* ( NEWLINE | EOF )
					{
					match("--"); 

					// PLSQLLexer.g:377:15: (~ ( '\\r' | '\\n' ) )*
					loop32:
					while (true) {
						int alt32=2;
						int LA32_0 = input.LA(1);
						if ( ((LA32_0 >= '\u0000' && LA32_0 <= '\t')||(LA32_0 >= '\u000B' && LA32_0 <= '\f')||(LA32_0 >= '\u000E' && LA32_0 <= '\uFFFF')) ) {
							alt32=1;
						}

						switch (alt32) {
						case 1 :
							// PLSQLLexer.g:
							{
							if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) {
								input.consume();
							}
							else {
								MismatchedSetException mse = new MismatchedSetException(null,input);
								recover(mse);
								throw mse;
							}
							}
							break;

						default :
							break loop32;
						}
					}

					// PLSQLLexer.g:377:35: ( NEWLINE | EOF )
					int alt33=2;
					int LA33_0 = input.LA(1);
					if ( (LA33_0=='\n'||LA33_0=='\r') ) {
						alt33=1;
					}

					else {
						alt33=2;
					}

					switch (alt33) {
						case 1 :
							// PLSQLLexer.g:377:36: NEWLINE
							{
							mNEWLINE(); 

							}
							break;
						case 2 :
							// PLSQLLexer.g:377:44: EOF
							{
							match(EOF); 

							}
							break;

					}

					}
					break;
				case 2 :
					// PLSQLLexer.g:378:10: '/*' ( options {greedy=false; } : . )* '*/'
					{
					match("/*"); 

					// PLSQLLexer.g:378:15: ( options {greedy=false; } : . )*
					loop34:
					while (true) {
						int alt34=2;
						int LA34_0 = input.LA(1);
						if ( (LA34_0=='*') ) {
							int LA34_1 = input.LA(2);
							if ( (LA34_1=='/') ) {
								alt34=2;
							}
							else if ( ((LA34_1 >= '\u0000' && LA34_1 <= '.')||(LA34_1 >= '0' && LA34_1 <= '\uFFFF')) ) {
								alt34=1;
							}

						}
						else if ( ((LA34_0 >= '\u0000' && LA34_0 <= ')')||(LA34_0 >= '+' && LA34_0 <= '\uFFFF')) ) {
							alt34=1;
						}

						switch (alt34) {
						case 1 :
							// PLSQLLexer.g:378:41: .
							{
							matchAny(); 
							}
							break;

						default :
							break loop34;
						}
					}

					match("*/"); 

					}
					break;

			}
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "COMMENT"

	// $ANTLR start "PROMPT"
	public final void mPROMPT() throws RecognitionException {
		try {
			int _type = PROMPT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:385:2: ( 'prompt' SPACE (~ ( '\\r' | '\\n' ) )* ( NEWLINE | EOF ) )
			// PLSQLLexer.g:385:4: 'prompt' SPACE (~ ( '\\r' | '\\n' ) )* ( NEWLINE | EOF )
			{
			match("prompt"); 

			mSPACE(); 

			// PLSQLLexer.g:385:19: (~ ( '\\r' | '\\n' ) )*
			loop36:
			while (true) {
				int alt36=2;
				int LA36_0 = input.LA(1);
				if ( ((LA36_0 >= '\u0000' && LA36_0 <= '\t')||(LA36_0 >= '\u000B' && LA36_0 <= '\f')||(LA36_0 >= '\u000E' && LA36_0 <= '\uFFFF')) ) {
					alt36=1;
				}

				switch (alt36) {
				case 1 :
					// PLSQLLexer.g:
					{
					if ( (input.LA(1) >= '\u0000' && input.LA(1) <= '\t')||(input.LA(1) >= '\u000B' && input.LA(1) <= '\f')||(input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					break loop36;
				}
			}

			// PLSQLLexer.g:385:39: ( NEWLINE | EOF )
			int alt37=2;
			int LA37_0 = input.LA(1);
			if ( (LA37_0=='\n'||LA37_0=='\r') ) {
				alt37=1;
			}

			else {
				alt37=2;
			}

			switch (alt37) {
				case 1 :
					// PLSQLLexer.g:385:40: NEWLINE
					{
					mNEWLINE(); 

					}
					break;
				case 2 :
					// PLSQLLexer.g:385:48: EOF
					{
					match(EOF); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PROMPT"

	// $ANTLR start "NEWLINE"
	public final void mNEWLINE() throws RecognitionException {
		try {
			// PLSQLLexer.g:394:5: ( '\\r' ( options {greedy=true; } : '\\n' )? | '\\n' )
			int alt39=2;
			int LA39_0 = input.LA(1);
			if ( (LA39_0=='\r') ) {
				alt39=1;
			}
			else if ( (LA39_0=='\n') ) {
				alt39=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 39, 0, input);
				throw nvae;
			}

			switch (alt39) {
				case 1 :
					// PLSQLLexer.g:394:10: '\\r' ( options {greedy=true; } : '\\n' )?
					{
					match('\r'); 
					// PLSQLLexer.g:394:15: ( options {greedy=true; } : '\\n' )?
					int alt38=2;
					int LA38_0 = input.LA(1);
					if ( (LA38_0=='\n') ) {
						alt38=1;
					}
					switch (alt38) {
						case 1 :
							// PLSQLLexer.g:394:39: '\\n'
							{
							match('\n'); 
							}
							break;

					}

					}
					break;
				case 2 :
					// PLSQLLexer.g:395:10: '\\n'
					{
					match('\n'); 
					}
					break;

			}
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "NEWLINE"

	// $ANTLR start "SPACE"
	public final void mSPACE() throws RecognitionException {
		try {
			// PLSQLLexer.g:401:10: ( ' ' | '\\t' )
			// PLSQLLexer.g:
			{
			if ( input.LA(1)=='\t'||input.LA(1)==' ' ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SPACE"

	// $ANTLR start "APPROXIMATE_NUM_LIT"
	public final void mAPPROXIMATE_NUM_LIT() throws RecognitionException {
		try {
			// PLSQLLexer.g:406:29: ()
			// PLSQLLexer.g:406:31: 
			{
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "APPROXIMATE_NUM_LIT"

	// $ANTLR start "MINUS_SIGN"
	public final void mMINUS_SIGN() throws RecognitionException {
		try {
			// PLSQLLexer.g:407:20: ()
			// PLSQLLexer.g:407:22: 
			{
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "MINUS_SIGN"

	// $ANTLR start "UNDERSCORE"
	public final void mUNDERSCORE() throws RecognitionException {
		try {
			// PLSQLLexer.g:408:20: ()
			// PLSQLLexer.g:408:22: 
			{
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "UNDERSCORE"

	// $ANTLR start "DOUBLE_PERIOD"
	public final void mDOUBLE_PERIOD() throws RecognitionException {
		try {
			// PLSQLLexer.g:409:23: ()
			// PLSQLLexer.g:409:25: 
			{
			}

		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "DOUBLE_PERIOD"

	// $ANTLR start "SQL92_RESERVED_ALL"
	public final void mSQL92_RESERVED_ALL() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ALL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:415:5: ( 'all' )
			// PLSQLLexer.g:415:10: 'all'
			{
			match("all"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ALL"

	// $ANTLR start "SQL92_RESERVED_ALTER"
	public final void mSQL92_RESERVED_ALTER() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ALTER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:419:5: ( 'alter' )
			// PLSQLLexer.g:419:10: 'alter'
			{
			match("alter"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ALTER"

	// $ANTLR start "SQL92_RESERVED_AND"
	public final void mSQL92_RESERVED_AND() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_AND;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:423:5: ( 'and' )
			// PLSQLLexer.g:423:10: 'and'
			{
			match("and"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_AND"

	// $ANTLR start "SQL92_RESERVED_ANY"
	public final void mSQL92_RESERVED_ANY() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ANY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:427:5: ( 'any' )
			// PLSQLLexer.g:427:10: 'any'
			{
			match("any"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ANY"

	// $ANTLR start "SQL92_RESERVED_AS"
	public final void mSQL92_RESERVED_AS() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_AS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:431:5: ( 'as' )
			// PLSQLLexer.g:431:10: 'as'
			{
			match("as"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_AS"

	// $ANTLR start "SQL92_RESERVED_ASC"
	public final void mSQL92_RESERVED_ASC() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ASC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:435:5: ( 'asc' )
			// PLSQLLexer.g:435:10: 'asc'
			{
			match("asc"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ASC"

	// $ANTLR start "SQL92_RESERVED_BEGIN"
	public final void mSQL92_RESERVED_BEGIN() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_BEGIN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:443:5: ( 'begin' )
			// PLSQLLexer.g:443:10: 'begin'
			{
			match("begin"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_BEGIN"

	// $ANTLR start "SQL92_RESERVED_BETWEEN"
	public final void mSQL92_RESERVED_BETWEEN() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_BETWEEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:447:5: ( 'between' )
			// PLSQLLexer.g:447:10: 'between'
			{
			match("between"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_BETWEEN"

	// $ANTLR start "SQL92_RESERVED_BY"
	public final void mSQL92_RESERVED_BY() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_BY;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:451:5: ( 'by' )
			// PLSQLLexer.g:451:10: 'by'
			{
			match("by"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_BY"

	// $ANTLR start "SQL92_RESERVED_CASE"
	public final void mSQL92_RESERVED_CASE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CASE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:455:5: ( 'case' )
			// PLSQLLexer.g:455:10: 'case'
			{
			match("case"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CASE"

	// $ANTLR start "SQL92_RESERVED_CHECK"
	public final void mSQL92_RESERVED_CHECK() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CHECK;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:459:5: ( 'check' )
			// PLSQLLexer.g:459:10: 'check'
			{
			match("check"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CHECK"

	// $ANTLR start "PLSQL_RESERVED_CLUSTERS"
	public final void mPLSQL_RESERVED_CLUSTERS() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_CLUSTERS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:463:5: ( 'clusters' )
			// PLSQLLexer.g:463:10: 'clusters'
			{
			match("clusters"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_CLUSTERS"

	// $ANTLR start "PLSQL_RESERVED_COLAUTH"
	public final void mPLSQL_RESERVED_COLAUTH() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_COLAUTH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:467:5: ( 'colauth' )
			// PLSQLLexer.g:467:10: 'colauth'
			{
			match("colauth"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_COLAUTH"

	// $ANTLR start "PLSQL_RESERVED_COMPRESS"
	public final void mPLSQL_RESERVED_COMPRESS() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_COMPRESS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:471:5: ( 'compress' )
			// PLSQLLexer.g:471:10: 'compress'
			{
			match("compress"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_COMPRESS"

	// $ANTLR start "SQL92_RESERVED_CONNECT"
	public final void mSQL92_RESERVED_CONNECT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CONNECT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:475:5: ( 'connect' )
			// PLSQLLexer.g:475:10: 'connect'
			{
			match("connect"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CONNECT"

	// $ANTLR start "PLSQL_NON_RESERVED_CONNECT_BY_ROOT"
	public final void mPLSQL_NON_RESERVED_CONNECT_BY_ROOT() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_CONNECT_BY_ROOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:483:5: ( 'connect_by_root' )
			// PLSQLLexer.g:483:10: 'connect_by_root'
			{
			match("connect_by_root"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_CONNECT_BY_ROOT"

	// $ANTLR start "PLSQL_RESERVED_CRASH"
	public final void mPLSQL_RESERVED_CRASH() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_CRASH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:487:5: ( 'crash' )
			// PLSQLLexer.g:487:10: 'crash'
			{
			match("crash"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_CRASH"

	// $ANTLR start "SQL92_RESERVED_CREATE"
	public final void mSQL92_RESERVED_CREATE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CREATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:491:5: ( 'create' )
			// PLSQLLexer.g:491:10: 'create'
			{
			match("create"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CREATE"

	// $ANTLR start "SQL92_RESERVED_CURRENT"
	public final void mSQL92_RESERVED_CURRENT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CURRENT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:495:5: ( 'current' )
			// PLSQLLexer.g:495:10: 'current'
			{
			match("current"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CURRENT"

	// $ANTLR start "SQL92_RESERVED_CURSOR"
	public final void mSQL92_RESERVED_CURSOR() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_CURSOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:499:5: ( 'cursor' )
			// PLSQLLexer.g:499:10: 'cursor'
			{
			match("cursor"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_CURSOR"

	// $ANTLR start "SQL92_RESERVED_DATE"
	public final void mSQL92_RESERVED_DATE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:503:5: ( 'date' )
			// PLSQLLexer.g:503:10: 'date'
			{
			match("date"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DATE"

	// $ANTLR start "SQL92_RESERVED_DECLARE"
	public final void mSQL92_RESERVED_DECLARE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DECLARE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:507:5: ( 'declare' )
			// PLSQLLexer.g:507:10: 'declare'
			{
			match("declare"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DECLARE"

	// $ANTLR start "SQL92_RESERVED_DEFAULT"
	public final void mSQL92_RESERVED_DEFAULT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DEFAULT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:511:5: ( 'default' )
			// PLSQLLexer.g:511:10: 'default'
			{
			match("default"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DEFAULT"

	// $ANTLR start "SQL92_RESERVED_DELETE"
	public final void mSQL92_RESERVED_DELETE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DELETE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:515:5: ( 'delete' )
			// PLSQLLexer.g:515:10: 'delete'
			{
			match("delete"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DELETE"

	// $ANTLR start "SQL92_RESERVED_DESC"
	public final void mSQL92_RESERVED_DESC() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DESC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:519:5: ( 'desc' )
			// PLSQLLexer.g:519:10: 'desc'
			{
			match("desc"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DESC"

	// $ANTLR start "SQL92_RESERVED_DISTINCT"
	public final void mSQL92_RESERVED_DISTINCT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DISTINCT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:523:5: ( 'distinct' )
			// PLSQLLexer.g:523:10: 'distinct'
			{
			match("distinct"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DISTINCT"

	// $ANTLR start "SQL92_RESERVED_DROP"
	public final void mSQL92_RESERVED_DROP() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_DROP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:527:5: ( 'drop' )
			// PLSQLLexer.g:527:10: 'drop'
			{
			match("drop"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_DROP"

	// $ANTLR start "SQL92_RESERVED_ELSE"
	public final void mSQL92_RESERVED_ELSE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ELSE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:531:5: ( 'else' )
			// PLSQLLexer.g:531:10: 'else'
			{
			match("else"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ELSE"

	// $ANTLR start "SQL92_RESERVED_END"
	public final void mSQL92_RESERVED_END() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_END;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:535:5: ( 'end' )
			// PLSQLLexer.g:535:10: 'end'
			{
			match("end"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_END"

	// $ANTLR start "SQL92_RESERVED_EXCEPTION"
	public final void mSQL92_RESERVED_EXCEPTION() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_EXCEPTION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken e=null;

			// PLSQLLexer.g:539:5: (e= 'exception' )
			// PLSQLLexer.g:539:10: e= 'exception'
			{
			int eStart = getCharIndex();
			match("exception"); 
			int eStartLine2611 = getLine();
			int eStartCharPos2611 = getCharPositionInLine();
			e = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, eStart, getCharIndex()-1);
			e.setLine(eStartLine2611);
			e.setCharPositionInLine(eStartCharPos2611);


			    e.setType(SQL92_RESERVED_EXCEPTION);
			    emit(e);
			    advanceInput();

			    _type = Token.INVALID_TOKEN_TYPE;
			    int markException = input.mark();

			    // Now loop over next Tokens in the input and eventually set Token's type to REGULAR_ID

			    // Subclassed version will return NULL unless EOF is reached.
			    // nextToken either returns NULL => then the next token is put into the queue tokenBuffer
			    // or it returns Token.EOF, then nothing is put into the queue
			    Token t1 = super.nextToken();
			    {    // This "if" handles the situation when the "exception" is the last text in the input.
			        if( t1 != null && t1.getType() == Token.EOF)
			        {
			             e.setType(REGULAR_ID);
			        } else {
			             t1 = tokenBuffer.pollLast(); // "withdraw" the next token from the queue
			             while(true)
			             {
			                 if(t1.getType() == EOF)   // is it EOF?
			                 {
			                     e.setType(REGULAR_ID);
			                     break;
			                 }

			                 if(t1.getChannel() == HIDDEN) // is it a white space? then advance to the next token
			                 {
			                     t1 = super.nextToken(); if( t1 == null) { t1 = tokenBuffer.pollLast(); };
			                     continue;
			                 }

			                 if( t1.getType() != SQL92_RESERVED_WHEN && t1.getType() != SEMICOLON) // is something other than "when"
			                 {
			                     e.setType(REGULAR_ID);
			                     break;
			                 }

			                 break; // we are in the model_clase do not rewrite anything
			              } // while true
			         } // else if( t1 != null && t1.getType() == Token.EOF)
			    }
			    input.rewind(markException);
			    
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_EXCEPTION"

	// $ANTLR start "PLSQL_RESERVED_EXCLUSIVE"
	public final void mPLSQL_RESERVED_EXCLUSIVE() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_EXCLUSIVE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:592:5: ( 'exclusive' )
			// PLSQLLexer.g:592:10: 'exclusive'
			{
			match("exclusive"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_EXCLUSIVE"

	// $ANTLR start "SQL92_RESERVED_EXISTS"
	public final void mSQL92_RESERVED_EXISTS() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_EXISTS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:596:5: ( 'exists' )
			// PLSQLLexer.g:596:10: 'exists'
			{
			match("exists"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_EXISTS"

	// $ANTLR start "SQL92_RESERVED_FALSE"
	public final void mSQL92_RESERVED_FALSE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_FALSE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:600:5: ( 'false' )
			// PLSQLLexer.g:600:10: 'false'
			{
			match("false"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_FALSE"

	// $ANTLR start "SQL92_RESERVED_FETCH"
	public final void mSQL92_RESERVED_FETCH() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_FETCH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:604:5: ( 'fetch' )
			// PLSQLLexer.g:604:10: 'fetch'
			{
			match("fetch"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_FETCH"

	// $ANTLR start "SQL92_RESERVED_FOR"
	public final void mSQL92_RESERVED_FOR() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_FOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:608:5: ( 'for' )
			// PLSQLLexer.g:608:10: 'for'
			{
			match("for"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_FOR"

	// $ANTLR start "SQL92_RESERVED_FROM"
	public final void mSQL92_RESERVED_FROM() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_FROM;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:612:5: ( 'from' )
			// PLSQLLexer.g:612:10: 'from'
			{
			match("from"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_FROM"

	// $ANTLR start "SQL92_RESERVED_GOTO"
	public final void mSQL92_RESERVED_GOTO() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_GOTO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:616:5: ( 'goto' )
			// PLSQLLexer.g:616:10: 'goto'
			{
			match("goto"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_GOTO"

	// $ANTLR start "SQL92_RESERVED_GRANT"
	public final void mSQL92_RESERVED_GRANT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_GRANT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:620:5: ( 'grant' )
			// PLSQLLexer.g:620:10: 'grant'
			{
			match("grant"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_GRANT"

	// $ANTLR start "SQL92_RESERVED_GROUP"
	public final void mSQL92_RESERVED_GROUP() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_GROUP;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:624:5: ( 'group' )
			// PLSQLLexer.g:624:10: 'group'
			{
			match("group"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_GROUP"

	// $ANTLR start "SQL92_RESERVED_HAVING"
	public final void mSQL92_RESERVED_HAVING() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_HAVING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:628:5: ( 'having' )
			// PLSQLLexer.g:628:10: 'having'
			{
			match("having"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_HAVING"

	// $ANTLR start "PLSQL_RESERVED_IDENTIFIED"
	public final void mPLSQL_RESERVED_IDENTIFIED() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_IDENTIFIED;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:632:5: ( 'identified' )
			// PLSQLLexer.g:632:10: 'identified'
			{
			match("identified"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_IDENTIFIED"

	// $ANTLR start "PLSQL_RESERVED_IF"
	public final void mPLSQL_RESERVED_IF() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_IF;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:636:5: ( 'if' )
			// PLSQLLexer.g:636:10: 'if'
			{
			match("if"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_IF"

	// $ANTLR start "SQL92_RESERVED_IN"
	public final void mSQL92_RESERVED_IN() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_IN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:640:5: ( 'in' )
			// PLSQLLexer.g:640:10: 'in'
			{
			match("in"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_IN"

	// $ANTLR start "PLSQL_RESERVED_INDEX"
	public final void mPLSQL_RESERVED_INDEX() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_INDEX;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:644:5: ( 'index' )
			// PLSQLLexer.g:644:10: 'index'
			{
			match("index"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_INDEX"

	// $ANTLR start "PLSQL_RESERVED_INDEXES"
	public final void mPLSQL_RESERVED_INDEXES() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_INDEXES;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:648:5: ( 'indexes' )
			// PLSQLLexer.g:648:10: 'indexes'
			{
			match("indexes"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_INDEXES"

	// $ANTLR start "SQL92_RESERVED_INSERT"
	public final void mSQL92_RESERVED_INSERT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_INSERT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:652:5: ( 'insert' )
			// PLSQLLexer.g:652:10: 'insert'
			{
			match("insert"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_INSERT"

	// $ANTLR start "SQL92_RESERVED_INTERSECT"
	public final void mSQL92_RESERVED_INTERSECT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_INTERSECT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:656:5: ( 'intersect' )
			// PLSQLLexer.g:656:10: 'intersect'
			{
			match("intersect"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_INTERSECT"

	// $ANTLR start "SQL92_RESERVED_INTO"
	public final void mSQL92_RESERVED_INTO() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_INTO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:660:5: ( 'into' )
			// PLSQLLexer.g:660:10: 'into'
			{
			match("into"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_INTO"

	// $ANTLR start "SQL92_RESERVED_IS"
	public final void mSQL92_RESERVED_IS() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_IS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:664:5: ( 'is' )
			// PLSQLLexer.g:664:10: 'is'
			{
			match("is"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_IS"

	// $ANTLR start "SQL92_RESERVED_LIKE"
	public final void mSQL92_RESERVED_LIKE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_LIKE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:668:5: ( 'like' )
			// PLSQLLexer.g:668:10: 'like'
			{
			match("like"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_LIKE"

	// $ANTLR start "PLSQL_RESERVED_LOCK"
	public final void mPLSQL_RESERVED_LOCK() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_LOCK;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:672:5: ( 'lock' )
			// PLSQLLexer.g:672:10: 'lock'
			{
			match("lock"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_LOCK"

	// $ANTLR start "PLSQL_RESERVED_MINUS"
	public final void mPLSQL_RESERVED_MINUS() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_MINUS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:676:5: ( 'minus' )
			// PLSQLLexer.g:676:10: 'minus'
			{
			match("minus"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_MINUS"

	// $ANTLR start "PLSQL_RESERVED_MODE"
	public final void mPLSQL_RESERVED_MODE() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_MODE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:680:5: ( 'mode' )
			// PLSQLLexer.g:680:10: 'mode'
			{
			match("mode"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_MODE"

	// $ANTLR start "PLSQL_RESERVED_NOCOMPRESS"
	public final void mPLSQL_RESERVED_NOCOMPRESS() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_NOCOMPRESS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:684:5: ( 'nocompress' )
			// PLSQLLexer.g:684:10: 'nocompress'
			{
			match("nocompress"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_NOCOMPRESS"

	// $ANTLR start "SQL92_RESERVED_NOT"
	public final void mSQL92_RESERVED_NOT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_NOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:688:5: ( 'not' )
			// PLSQLLexer.g:688:10: 'not'
			{
			match("not"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_NOT"

	// $ANTLR start "PLSQL_RESERVED_NOWAIT"
	public final void mPLSQL_RESERVED_NOWAIT() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_NOWAIT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:692:5: ( 'nowait' )
			// PLSQLLexer.g:692:10: 'nowait'
			{
			match("nowait"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_NOWAIT"

	// $ANTLR start "SQL92_RESERVED_NULL"
	public final void mSQL92_RESERVED_NULL() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_NULL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:696:5: ( 'null' )
			// PLSQLLexer.g:696:10: 'null'
			{
			match("null"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_NULL"

	// $ANTLR start "SQL92_RESERVED_OF"
	public final void mSQL92_RESERVED_OF() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_OF;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:700:5: ( 'of' )
			// PLSQLLexer.g:700:10: 'of'
			{
			match("of"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_OF"

	// $ANTLR start "SQL92_RESERVED_ON"
	public final void mSQL92_RESERVED_ON() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ON;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:704:5: ( 'on' )
			// PLSQLLexer.g:704:10: 'on'
			{
			match("on"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ON"

	// $ANTLR start "SQL92_RESERVED_OPTION"
	public final void mSQL92_RESERVED_OPTION() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_OPTION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:708:5: ( 'option' )
			// PLSQLLexer.g:708:10: 'option'
			{
			match("option"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_OPTION"

	// $ANTLR start "SQL92_RESERVED_OR"
	public final void mSQL92_RESERVED_OR() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_OR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:712:5: ( 'or' )
			// PLSQLLexer.g:712:10: 'or'
			{
			match("or"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_OR"

	// $ANTLR start "SQL92_RESERVED_ORDER"
	public final void mSQL92_RESERVED_ORDER() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_ORDER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:716:5: ( 'order' )
			// PLSQLLexer.g:716:10: 'order'
			{
			match("order"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_ORDER"

	// $ANTLR start "SQL92_RESERVED_OVERLAPS"
	public final void mSQL92_RESERVED_OVERLAPS() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_OVERLAPS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:720:5: ( 'overlaps' )
			// PLSQLLexer.g:720:10: 'overlaps'
			{
			match("overlaps"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_OVERLAPS"

	// $ANTLR start "SQL92_RESERVED_PRIOR"
	public final void mSQL92_RESERVED_PRIOR() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_PRIOR;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:724:5: ( 'prior' )
			// PLSQLLexer.g:724:10: 'prior'
			{
			match("prior"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_PRIOR"

	// $ANTLR start "SQL92_RESERVED_PROCEDURE"
	public final void mSQL92_RESERVED_PROCEDURE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_PROCEDURE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:728:5: ( 'procedure' )
			// PLSQLLexer.g:728:10: 'procedure'
			{
			match("procedure"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_PROCEDURE"

	// $ANTLR start "SQL92_RESERVED_PUBLIC"
	public final void mSQL92_RESERVED_PUBLIC() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_PUBLIC;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:732:5: ( 'public' )
			// PLSQLLexer.g:732:10: 'public'
			{
			match("public"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_PUBLIC"

	// $ANTLR start "PLSQL_RESERVED_RESOURCE"
	public final void mPLSQL_RESERVED_RESOURCE() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_RESOURCE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:736:5: ( 'resource' )
			// PLSQLLexer.g:736:10: 'resource'
			{
			match("resource"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_RESOURCE"

	// $ANTLR start "SQL92_RESERVED_REVOKE"
	public final void mSQL92_RESERVED_REVOKE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_REVOKE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:740:5: ( 'revoke' )
			// PLSQLLexer.g:740:10: 'revoke'
			{
			match("revoke"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_REVOKE"

	// $ANTLR start "SQL92_RESERVED_SELECT"
	public final void mSQL92_RESERVED_SELECT() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_SELECT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:744:5: ( 'select' )
			// PLSQLLexer.g:744:10: 'select'
			{
			match("select"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_SELECT"

	// $ANTLR start "PLSQL_RESERVED_SHARE"
	public final void mPLSQL_RESERVED_SHARE() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_SHARE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:748:5: ( 'share' )
			// PLSQLLexer.g:748:10: 'share'
			{
			match("share"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_SHARE"

	// $ANTLR start "SQL92_RESERVED_SIZE"
	public final void mSQL92_RESERVED_SIZE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_SIZE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:752:5: ( 'size' )
			// PLSQLLexer.g:752:10: 'size'
			{
			match("size"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_SIZE"

	// $ANTLR start "PLSQL_RESERVED_START"
	public final void mPLSQL_RESERVED_START() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_START;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:760:5: ( 'start' )
			// PLSQLLexer.g:760:10: 'start'
			{
			match("start"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_START"

	// $ANTLR start "PLSQL_RESERVED_TABAUTH"
	public final void mPLSQL_RESERVED_TABAUTH() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_TABAUTH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:764:5: ( 'tabauth' )
			// PLSQLLexer.g:764:10: 'tabauth'
			{
			match("tabauth"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_TABAUTH"

	// $ANTLR start "SQL92_RESERVED_TABLE"
	public final void mSQL92_RESERVED_TABLE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_TABLE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:768:5: ( 'table' )
			// PLSQLLexer.g:768:10: 'table'
			{
			match("table"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_TABLE"

	// $ANTLR start "SQL92_RESERVED_THE"
	public final void mSQL92_RESERVED_THE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_THE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:772:5: ( 'the' )
			// PLSQLLexer.g:772:10: 'the'
			{
			match("the"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_THE"

	// $ANTLR start "SQL92_RESERVED_THEN"
	public final void mSQL92_RESERVED_THEN() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_THEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:776:5: ( 'then' )
			// PLSQLLexer.g:776:10: 'then'
			{
			match("then"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_THEN"

	// $ANTLR start "SQL92_RESERVED_TO"
	public final void mSQL92_RESERVED_TO() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_TO;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:780:5: ( 'to' )
			// PLSQLLexer.g:780:10: 'to'
			{
			match("to"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_TO"

	// $ANTLR start "SQL92_RESERVED_TRUE"
	public final void mSQL92_RESERVED_TRUE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_TRUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:784:5: ( 'true' )
			// PLSQLLexer.g:784:10: 'true'
			{
			match("true"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_TRUE"

	// $ANTLR start "SQL92_RESERVED_UNION"
	public final void mSQL92_RESERVED_UNION() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_UNION;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:788:5: ( 'union' )
			// PLSQLLexer.g:788:10: 'union'
			{
			match("union"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_UNION"

	// $ANTLR start "SQL92_RESERVED_UNIQUE"
	public final void mSQL92_RESERVED_UNIQUE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_UNIQUE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:792:5: ( 'unique' )
			// PLSQLLexer.g:792:10: 'unique'
			{
			match("unique"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_UNIQUE"

	// $ANTLR start "SQL92_RESERVED_UPDATE"
	public final void mSQL92_RESERVED_UPDATE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_UPDATE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:796:5: ( 'update' )
			// PLSQLLexer.g:796:10: 'update'
			{
			match("update"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_UPDATE"

	// $ANTLR start "SQL92_RESERVED_VALUES"
	public final void mSQL92_RESERVED_VALUES() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_VALUES;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:800:5: ( 'values' )
			// PLSQLLexer.g:800:10: 'values'
			{
			match("values"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_VALUES"

	// $ANTLR start "SQL92_RESERVED_VIEW"
	public final void mSQL92_RESERVED_VIEW() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_VIEW;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:804:5: ( 'view' )
			// PLSQLLexer.g:804:10: 'view'
			{
			match("view"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_VIEW"

	// $ANTLR start "PLSQL_RESERVED_VIEWS"
	public final void mPLSQL_RESERVED_VIEWS() throws RecognitionException {
		try {
			int _type = PLSQL_RESERVED_VIEWS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:808:5: ( 'views' )
			// PLSQLLexer.g:808:10: 'views'
			{
			match("views"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_RESERVED_VIEWS"

	// $ANTLR start "SQL92_RESERVED_WHEN"
	public final void mSQL92_RESERVED_WHEN() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_WHEN;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:812:5: ( 'when' )
			// PLSQLLexer.g:812:10: 'when'
			{
			match("when"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_WHEN"

	// $ANTLR start "SQL92_RESERVED_WHERE"
	public final void mSQL92_RESERVED_WHERE() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_WHERE;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:816:5: ( 'where' )
			// PLSQLLexer.g:816:10: 'where'
			{
			match("where"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_WHERE"

	// $ANTLR start "SQL92_RESERVED_WITH"
	public final void mSQL92_RESERVED_WITH() throws RecognitionException {
		try {
			int _type = SQL92_RESERVED_WITH;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:820:5: ( 'with' )
			// PLSQLLexer.g:820:10: 'with'
			{
			match("with"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "SQL92_RESERVED_WITH"

	// $ANTLR start "PLSQL_NON_RESERVED_CAST"
	public final void mPLSQL_NON_RESERVED_CAST() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_CAST;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:824:5: ( 'cast' )
			// PLSQLLexer.g:824:10: 'cast'
			{
			match("cast"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_CAST"

	// $ANTLR start "PLSQL_NON_RESERVED_MULTISET"
	public final void mPLSQL_NON_RESERVED_MULTISET() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_MULTISET;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:828:2: ( 'multiset' )
			// PLSQLLexer.g:828:4: 'multiset'
			{
			match("multiset"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_MULTISET"

	// $ANTLR start "PLSQL_NON_RESERVED_USING"
	public final void mPLSQL_NON_RESERVED_USING() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_USING;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:832:5: ( 'using' )
			// PLSQLLexer.g:832:10: 'using'
			{
			match("using"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_USING"

	// $ANTLR start "PLSQL_NON_RESERVED_MODEL"
	public final void mPLSQL_NON_RESERVED_MODEL() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_MODEL;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			CommonToken m=null;

			// PLSQLLexer.g:836:5: (m= 'model' )
			// PLSQLLexer.g:836:10: m= 'model'
			{
			int mStart = getCharIndex();
			match("model"); 
			int mStartLine3849 = getLine();
			int mStartCharPos3849 = getCharPositionInLine();
			m = new CommonToken(input, Token.INVALID_TOKEN_TYPE, Token.DEFAULT_CHANNEL, mStart, getCharIndex()-1);
			m.setLine(mStartLine3849);
			m.setCharPositionInLine(mStartCharPos3849);


			         // "model" is a keyword if and only if it is followed by ("main"|"partition"|"dimension"|"unique"|"return")
			         // otherwise it is a identifier(REGULAR_ID).
			         // This wodoo implements something like context sensitive lexer.
			         // Here we've matched the word "model". Then the Token is created and en-queued in tokenBuffer
			         // We still remember the reference(m) onto this Token
			         m.setType(PLSQL_NON_RESERVED_MODEL);
			         emit(m);
			         advanceInput();

			         _type = Token.INVALID_TOKEN_TYPE;
			         int markModel = input.mark();

			         // Now loop over next Tokens in the input and eventually set Token's type to REGULAR_ID

			         // Subclassed version will return NULL unless EOF is reached.
			         // nextToken either returns NULL => then the next token is put into the queue tokenBuffer
			         // or it returns Token.EOF, then nothing is put into the queue
			         Token t1 = super.nextToken();
			         {    // This "if" handles the situation when the "model" is the last text in the input.
			              if( t1 != null && t1.getType() == Token.EOF)
			              {
			                  m.setType(REGULAR_ID);
			              } else {
			                  t1 = tokenBuffer.pollLast(); // "withdraw" the next token from the queue
			                  while(true)
			                  {
			                     if(t1.getType() == EOF)   // is it EOF?
			                     {
			                         m.setType(REGULAR_ID);
			                         break;
			                     }

			                     if(t1.getChannel() == HIDDEN) // is it a white space? then advance to the next token
			                     {
			                         t1 = super.nextToken(); if( t1 == null) { t1 = tokenBuffer.pollLast(); };
			                         continue;
			                     }
			                       
			                     if( t1.getType() == SQL92_RESERVED_UNIQUE)
			                     {
			                         break;
			                     }
			                     if( t1.getType() != REGULAR_ID || // is something other than ("main"|"partition"|"dimension"|"return")
			                        ( !t1.getText().equalsIgnoreCase("main") &&
			                          !t1.getText().equalsIgnoreCase("partition") &&
			                          !t1.getText().equalsIgnoreCase("return") &&
			                          !t1.getText().equalsIgnoreCase("dimension")
			                       ))
			                     {
			                         m.setType(REGULAR_ID);
			                         break;
			                     }

			                     break; // we are in the model_clase do not rewrite anything
			                  } // while true
			              } // else if( t1 != null && t1.getType() == Token.EOF)
			         }
			         input.rewind(markModel);
			    
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_MODEL"

	// $ANTLR start "PLSQL_NON_RESERVED_ELSIF"
	public final void mPLSQL_NON_RESERVED_ELSIF() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_ELSIF;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:900:5: ( 'elsif' )
			// PLSQLLexer.g:900:10: 'elsif'
			{
			match("elsif"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_ELSIF"

	// $ANTLR start "PLSQL_NON_RESERVED_PIVOT"
	public final void mPLSQL_NON_RESERVED_PIVOT() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_PIVOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:904:5: ( 'pivot' )
			// PLSQLLexer.g:904:10: 'pivot'
			{
			match("pivot"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_PIVOT"

	// $ANTLR start "PLSQL_NON_RESERVED_UNPIVOT"
	public final void mPLSQL_NON_RESERVED_UNPIVOT() throws RecognitionException {
		try {
			int _type = PLSQL_NON_RESERVED_UNPIVOT;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:908:5: ( 'unpivot' )
			// PLSQLLexer.g:908:10: 'unpivot'
			{
			match("unpivot"); 

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "PLSQL_NON_RESERVED_UNPIVOT"

	// $ANTLR start "REGULAR_ID"
	public final void mREGULAR_ID() throws RecognitionException {
		try {
			int _type = REGULAR_ID;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:912:5: ( ( SIMPLE_LETTER ) ( SIMPLE_LETTER | '$' | '_' | '#' | '0' .. '9' )* )
			// PLSQLLexer.g:912:10: ( SIMPLE_LETTER ) ( SIMPLE_LETTER | '$' | '_' | '#' | '0' .. '9' )*
			{
			if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z')||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
				input.consume();
			}
			else {
				MismatchedSetException mse = new MismatchedSetException(null,input);
				recover(mse);
				throw mse;
			}
			// PLSQLLexer.g:912:26: ( SIMPLE_LETTER | '$' | '_' | '#' | '0' .. '9' )*
			loop40:
			while (true) {
				int alt40=2;
				int LA40_0 = input.LA(1);
				if ( ((LA40_0 >= '#' && LA40_0 <= '$')||(LA40_0 >= '0' && LA40_0 <= '9')||(LA40_0 >= 'A' && LA40_0 <= 'Z')||LA40_0=='_'||(LA40_0 >= 'a' && LA40_0 <= 'z')) ) {
					alt40=1;
				}

				switch (alt40) {
				case 1 :
					// PLSQLLexer.g:
					{
					if ( (input.LA(1) >= '#' && input.LA(1) <= '$')||(input.LA(1) >= '0' && input.LA(1) <= '9')||(input.LA(1) >= 'A' && input.LA(1) <= 'Z')||input.LA(1)=='_'||(input.LA(1) >= 'a' && input.LA(1) <= 'z') ) {
						input.consume();
					}
					else {
						MismatchedSetException mse = new MismatchedSetException(null,input);
						recover(mse);
						throw mse;
					}
					}
					break;

				default :
					break loop40;
				}
			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "REGULAR_ID"

	// $ANTLR start "ZV"
	public final void mZV() throws RecognitionException {
		try {
			int _type = ZV;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// PLSQLLexer.g:916:5: ( '@!' )
			// PLSQLLexer.g:916:10: '@!'
			{
			match("@!"); 

			_channel=HIDDEN;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
	// $ANTLR end "ZV"

	@Override
	public void mTokens() throws RecognitionException {
		// PLSQLLexer.g:1:8: ( FOR_NOTATION | NATIONAL_CHAR_STRING_LIT | BIT_STRING_LIT | HEX_STRING_LIT | PERIOD | EXACT_NUM_LIT | CHAR_STRING | CHAR_STRING_PERL | DELIMITED_ID | PERCENT | AMPERSAND | LEFT_PAREN | RIGHT_PAREN | DOUBLE_ASTERISK | ASTERISK | PLUS_SIGN | COMMA | SOLIDUS | AT_SIGN | ASSIGN_OP | BINDVAR | COLON | SEMICOLON | LESS_THAN_OR_EQUALS_OP | LESS_THAN_OP | GREATER_THAN_OR_EQUALS_OP | NOT_EQUAL_OP | CARRET_OPERATOR_PART | TILDE_OPERATOR_PART | EXCLAMATION_OPERATOR_PART | GREATER_THAN_OP | CONCATENATION_OP | VERTICAL_BAR | EQUALS_OP | LEFT_BRACKET | RIGHT_BRACKET | INTRODUCER | SEPARATOR | PROMPT | SQL92_RESERVED_ALL | SQL92_RESERVED_ALTER | SQL92_RESERVED_AND | SQL92_RESERVED_ANY | SQL92_RESERVED_AS | SQL92_RESERVED_ASC | SQL92_RESERVED_BEGIN | SQL92_RESERVED_BETWEEN | SQL92_RESERVED_BY | SQL92_RESERVED_CASE | SQL92_RESERVED_CHECK | PLSQL_RESERVED_CLUSTERS | PLSQL_RESERVED_COLAUTH | PLSQL_RESERVED_COMPRESS | SQL92_RESERVED_CONNECT | PLSQL_NON_RESERVED_CONNECT_BY_ROOT | PLSQL_RESERVED_CRASH | SQL92_RESERVED_CREATE | SQL92_RESERVED_CURRENT | SQL92_RESERVED_CURSOR | SQL92_RESERVED_DATE | SQL92_RESERVED_DECLARE | SQL92_RESERVED_DEFAULT | SQL92_RESERVED_DELETE | SQL92_RESERVED_DESC | SQL92_RESERVED_DISTINCT | SQL92_RESERVED_DROP | SQL92_RESERVED_ELSE | SQL92_RESERVED_END | SQL92_RESERVED_EXCEPTION | PLSQL_RESERVED_EXCLUSIVE | SQL92_RESERVED_EXISTS | SQL92_RESERVED_FALSE | SQL92_RESERVED_FETCH | SQL92_RESERVED_FOR | SQL92_RESERVED_FROM | SQL92_RESERVED_GOTO | SQL92_RESERVED_GRANT | SQL92_RESERVED_GROUP | SQL92_RESERVED_HAVING | PLSQL_RESERVED_IDENTIFIED | PLSQL_RESERVED_IF | SQL92_RESERVED_IN | PLSQL_RESERVED_INDEX | PLSQL_RESERVED_INDEXES | SQL92_RESERVED_INSERT | SQL92_RESERVED_INTERSECT | SQL92_RESERVED_INTO | SQL92_RESERVED_IS | SQL92_RESERVED_LIKE | PLSQL_RESERVED_LOCK | PLSQL_RESERVED_MINUS | PLSQL_RESERVED_MODE | PLSQL_RESERVED_NOCOMPRESS | SQL92_RESERVED_NOT | PLSQL_RESERVED_NOWAIT | SQL92_RESERVED_NULL | SQL92_RESERVED_OF | SQL92_RESERVED_ON | SQL92_RESERVED_OPTION | SQL92_RESERVED_OR | SQL92_RESERVED_ORDER | SQL92_RESERVED_OVERLAPS | SQL92_RESERVED_PRIOR | SQL92_RESERVED_PROCEDURE | SQL92_RESERVED_PUBLIC | PLSQL_RESERVED_RESOURCE | SQL92_RESERVED_REVOKE | SQL92_RESERVED_SELECT | PLSQL_RESERVED_SHARE | SQL92_RESERVED_SIZE | PLSQL_RESERVED_START | PLSQL_RESERVED_TABAUTH | SQL92_RESERVED_TABLE | SQL92_RESERVED_THE | SQL92_RESERVED_THEN | SQL92_RESERVED_TO | SQL92_RESERVED_TRUE | SQL92_RESERVED_UNION | SQL92_RESERVED_UNIQUE | SQL92_RESERVED_UPDATE | SQL92_RESERVED_VALUES | SQL92_RESERVED_VIEW | PLSQL_RESERVED_VIEWS | SQL92_RESERVED_WHEN | SQL92_RESERVED_WHERE | SQL92_RESERVED_WITH | PLSQL_NON_RESERVED_CAST | PLSQL_NON_RESERVED_MULTISET | PLSQL_NON_RESERVED_USING | PLSQL_NON_RESERVED_MODEL | PLSQL_NON_RESERVED_ELSIF | PLSQL_NON_RESERVED_PIVOT | PLSQL_NON_RESERVED_UNPIVOT | REGULAR_ID | ZV )
		int alt41=135;
		alt41 = dfa41.predict(input);
		switch (alt41) {
			case 1 :
				// PLSQLLexer.g:1:10: FOR_NOTATION
				{
				mFOR_NOTATION(); 

				}
				break;
			case 2 :
				// PLSQLLexer.g:1:23: NATIONAL_CHAR_STRING_LIT
				{
				mNATIONAL_CHAR_STRING_LIT(); 

				}
				break;
			case 3 :
				// PLSQLLexer.g:1:48: BIT_STRING_LIT
				{
				mBIT_STRING_LIT(); 

				}
				break;
			case 4 :
				// PLSQLLexer.g:1:63: HEX_STRING_LIT
				{
				mHEX_STRING_LIT(); 

				}
				break;
			case 5 :
				// PLSQLLexer.g:1:78: PERIOD
				{
				mPERIOD(); 

				}
				break;
			case 6 :
				// PLSQLLexer.g:1:85: EXACT_NUM_LIT
				{
				mEXACT_NUM_LIT(); 

				}
				break;
			case 7 :
				// PLSQLLexer.g:1:99: CHAR_STRING
				{
				mCHAR_STRING(); 

				}
				break;
			case 8 :
				// PLSQLLexer.g:1:111: CHAR_STRING_PERL
				{
				mCHAR_STRING_PERL(); 

				}
				break;
			case 9 :
				// PLSQLLexer.g:1:128: DELIMITED_ID
				{
				mDELIMITED_ID(); 

				}
				break;
			case 10 :
				// PLSQLLexer.g:1:141: PERCENT
				{
				mPERCENT(); 

				}
				break;
			case 11 :
				// PLSQLLexer.g:1:149: AMPERSAND
				{
				mAMPERSAND(); 

				}
				break;
			case 12 :
				// PLSQLLexer.g:1:159: LEFT_PAREN
				{
				mLEFT_PAREN(); 

				}
				break;
			case 13 :
				// PLSQLLexer.g:1:170: RIGHT_PAREN
				{
				mRIGHT_PAREN(); 

				}
				break;
			case 14 :
				// PLSQLLexer.g:1:182: DOUBLE_ASTERISK
				{
				mDOUBLE_ASTERISK(); 

				}
				break;
			case 15 :
				// PLSQLLexer.g:1:198: ASTERISK
				{
				mASTERISK(); 

				}
				break;
			case 16 :
				// PLSQLLexer.g:1:207: PLUS_SIGN
				{
				mPLUS_SIGN(); 

				}
				break;
			case 17 :
				// PLSQLLexer.g:1:217: COMMA
				{
				mCOMMA(); 

				}
				break;
			case 18 :
				// PLSQLLexer.g:1:223: SOLIDUS
				{
				mSOLIDUS(); 

				}
				break;
			case 19 :
				// PLSQLLexer.g:1:231: AT_SIGN
				{
				mAT_SIGN(); 

				}
				break;
			case 20 :
				// PLSQLLexer.g:1:239: ASSIGN_OP
				{
				mASSIGN_OP(); 

				}
				break;
			case 21 :
				// PLSQLLexer.g:1:249: BINDVAR
				{
				mBINDVAR(); 

				}
				break;
			case 22 :
				// PLSQLLexer.g:1:257: COLON
				{
				mCOLON(); 

				}
				break;
			case 23 :
				// PLSQLLexer.g:1:263: SEMICOLON
				{
				mSEMICOLON(); 

				}
				break;
			case 24 :
				// PLSQLLexer.g:1:273: LESS_THAN_OR_EQUALS_OP
				{
				mLESS_THAN_OR_EQUALS_OP(); 

				}
				break;
			case 25 :
				// PLSQLLexer.g:1:296: LESS_THAN_OP
				{
				mLESS_THAN_OP(); 

				}
				break;
			case 26 :
				// PLSQLLexer.g:1:309: GREATER_THAN_OR_EQUALS_OP
				{
				mGREATER_THAN_OR_EQUALS_OP(); 

				}
				break;
			case 27 :
				// PLSQLLexer.g:1:335: NOT_EQUAL_OP
				{
				mNOT_EQUAL_OP(); 

				}
				break;
			case 28 :
				// PLSQLLexer.g:1:348: CARRET_OPERATOR_PART
				{
				mCARRET_OPERATOR_PART(); 

				}
				break;
			case 29 :
				// PLSQLLexer.g:1:369: TILDE_OPERATOR_PART
				{
				mTILDE_OPERATOR_PART(); 

				}
				break;
			case 30 :
				// PLSQLLexer.g:1:389: EXCLAMATION_OPERATOR_PART
				{
				mEXCLAMATION_OPERATOR_PART(); 

				}
				break;
			case 31 :
				// PLSQLLexer.g:1:415: GREATER_THAN_OP
				{
				mGREATER_THAN_OP(); 

				}
				break;
			case 32 :
				// PLSQLLexer.g:1:431: CONCATENATION_OP
				{
				mCONCATENATION_OP(); 

				}
				break;
			case 33 :
				// PLSQLLexer.g:1:448: VERTICAL_BAR
				{
				mVERTICAL_BAR(); 

				}
				break;
			case 34 :
				// PLSQLLexer.g:1:461: EQUALS_OP
				{
				mEQUALS_OP(); 

				}
				break;
			case 35 :
				// PLSQLLexer.g:1:471: LEFT_BRACKET
				{
				mLEFT_BRACKET(); 

				}
				break;
			case 36 :
				// PLSQLLexer.g:1:484: RIGHT_BRACKET
				{
				mRIGHT_BRACKET(); 

				}
				break;
			case 37 :
				// PLSQLLexer.g:1:498: INTRODUCER
				{
				mINTRODUCER(); 

				}
				break;
			case 38 :
				// PLSQLLexer.g:1:509: SEPARATOR
				{
				mSEPARATOR(); 

				}
				break;
			case 39 :
				// PLSQLLexer.g:1:519: PROMPT
				{
				mPROMPT(); 

				}
				break;
			case 40 :
				// PLSQLLexer.g:1:526: SQL92_RESERVED_ALL
				{
				mSQL92_RESERVED_ALL(); 

				}
				break;
			case 41 :
				// PLSQLLexer.g:1:545: SQL92_RESERVED_ALTER
				{
				mSQL92_RESERVED_ALTER(); 

				}
				break;
			case 42 :
				// PLSQLLexer.g:1:566: SQL92_RESERVED_AND
				{
				mSQL92_RESERVED_AND(); 

				}
				break;
			case 43 :
				// PLSQLLexer.g:1:585: SQL92_RESERVED_ANY
				{
				mSQL92_RESERVED_ANY(); 

				}
				break;
			case 44 :
				// PLSQLLexer.g:1:604: SQL92_RESERVED_AS
				{
				mSQL92_RESERVED_AS(); 

				}
				break;
			case 45 :
				// PLSQLLexer.g:1:622: SQL92_RESERVED_ASC
				{
				mSQL92_RESERVED_ASC(); 

				}
				break;
			case 46 :
				// PLSQLLexer.g:1:641: SQL92_RESERVED_BEGIN
				{
				mSQL92_RESERVED_BEGIN(); 

				}
				break;
			case 47 :
				// PLSQLLexer.g:1:662: SQL92_RESERVED_BETWEEN
				{
				mSQL92_RESERVED_BETWEEN(); 

				}
				break;
			case 48 :
				// PLSQLLexer.g:1:685: SQL92_RESERVED_BY
				{
				mSQL92_RESERVED_BY(); 

				}
				break;
			case 49 :
				// PLSQLLexer.g:1:703: SQL92_RESERVED_CASE
				{
				mSQL92_RESERVED_CASE(); 

				}
				break;
			case 50 :
				// PLSQLLexer.g:1:723: SQL92_RESERVED_CHECK
				{
				mSQL92_RESERVED_CHECK(); 

				}
				break;
			case 51 :
				// PLSQLLexer.g:1:744: PLSQL_RESERVED_CLUSTERS
				{
				mPLSQL_RESERVED_CLUSTERS(); 

				}
				break;
			case 52 :
				// PLSQLLexer.g:1:768: PLSQL_RESERVED_COLAUTH
				{
				mPLSQL_RESERVED_COLAUTH(); 

				}
				break;
			case 53 :
				// PLSQLLexer.g:1:791: PLSQL_RESERVED_COMPRESS
				{
				mPLSQL_RESERVED_COMPRESS(); 

				}
				break;
			case 54 :
				// PLSQLLexer.g:1:815: SQL92_RESERVED_CONNECT
				{
				mSQL92_RESERVED_CONNECT(); 

				}
				break;
			case 55 :
				// PLSQLLexer.g:1:838: PLSQL_NON_RESERVED_CONNECT_BY_ROOT
				{
				mPLSQL_NON_RESERVED_CONNECT_BY_ROOT(); 

				}
				break;
			case 56 :
				// PLSQLLexer.g:1:873: PLSQL_RESERVED_CRASH
				{
				mPLSQL_RESERVED_CRASH(); 

				}
				break;
			case 57 :
				// PLSQLLexer.g:1:894: SQL92_RESERVED_CREATE
				{
				mSQL92_RESERVED_CREATE(); 

				}
				break;
			case 58 :
				// PLSQLLexer.g:1:916: SQL92_RESERVED_CURRENT
				{
				mSQL92_RESERVED_CURRENT(); 

				}
				break;
			case 59 :
				// PLSQLLexer.g:1:939: SQL92_RESERVED_CURSOR
				{
				mSQL92_RESERVED_CURSOR(); 

				}
				break;
			case 60 :
				// PLSQLLexer.g:1:961: SQL92_RESERVED_DATE
				{
				mSQL92_RESERVED_DATE(); 

				}
				break;
			case 61 :
				// PLSQLLexer.g:1:981: SQL92_RESERVED_DECLARE
				{
				mSQL92_RESERVED_DECLARE(); 

				}
				break;
			case 62 :
				// PLSQLLexer.g:1:1004: SQL92_RESERVED_DEFAULT
				{
				mSQL92_RESERVED_DEFAULT(); 

				}
				break;
			case 63 :
				// PLSQLLexer.g:1:1027: SQL92_RESERVED_DELETE
				{
				mSQL92_RESERVED_DELETE(); 

				}
				break;
			case 64 :
				// PLSQLLexer.g:1:1049: SQL92_RESERVED_DESC
				{
				mSQL92_RESERVED_DESC(); 

				}
				break;
			case 65 :
				// PLSQLLexer.g:1:1069: SQL92_RESERVED_DISTINCT
				{
				mSQL92_RESERVED_DISTINCT(); 

				}
				break;
			case 66 :
				// PLSQLLexer.g:1:1093: SQL92_RESERVED_DROP
				{
				mSQL92_RESERVED_DROP(); 

				}
				break;
			case 67 :
				// PLSQLLexer.g:1:1113: SQL92_RESERVED_ELSE
				{
				mSQL92_RESERVED_ELSE(); 

				}
				break;
			case 68 :
				// PLSQLLexer.g:1:1133: SQL92_RESERVED_END
				{
				mSQL92_RESERVED_END(); 

				}
				break;
			case 69 :
				// PLSQLLexer.g:1:1152: SQL92_RESERVED_EXCEPTION
				{
				mSQL92_RESERVED_EXCEPTION(); 

				}
				break;
			case 70 :
				// PLSQLLexer.g:1:1177: PLSQL_RESERVED_EXCLUSIVE
				{
				mPLSQL_RESERVED_EXCLUSIVE(); 

				}
				break;
			case 71 :
				// PLSQLLexer.g:1:1202: SQL92_RESERVED_EXISTS
				{
				mSQL92_RESERVED_EXISTS(); 

				}
				break;
			case 72 :
				// PLSQLLexer.g:1:1224: SQL92_RESERVED_FALSE
				{
				mSQL92_RESERVED_FALSE(); 

				}
				break;
			case 73 :
				// PLSQLLexer.g:1:1245: SQL92_RESERVED_FETCH
				{
				mSQL92_RESERVED_FETCH(); 

				}
				break;
			case 74 :
				// PLSQLLexer.g:1:1266: SQL92_RESERVED_FOR
				{
				mSQL92_RESERVED_FOR(); 

				}
				break;
			case 75 :
				// PLSQLLexer.g:1:1285: SQL92_RESERVED_FROM
				{
				mSQL92_RESERVED_FROM(); 

				}
				break;
			case 76 :
				// PLSQLLexer.g:1:1305: SQL92_RESERVED_GOTO
				{
				mSQL92_RESERVED_GOTO(); 

				}
				break;
			case 77 :
				// PLSQLLexer.g:1:1325: SQL92_RESERVED_GRANT
				{
				mSQL92_RESERVED_GRANT(); 

				}
				break;
			case 78 :
				// PLSQLLexer.g:1:1346: SQL92_RESERVED_GROUP
				{
				mSQL92_RESERVED_GROUP(); 

				}
				break;
			case 79 :
				// PLSQLLexer.g:1:1367: SQL92_RESERVED_HAVING
				{
				mSQL92_RESERVED_HAVING(); 

				}
				break;
			case 80 :
				// PLSQLLexer.g:1:1389: PLSQL_RESERVED_IDENTIFIED
				{
				mPLSQL_RESERVED_IDENTIFIED(); 

				}
				break;
			case 81 :
				// PLSQLLexer.g:1:1415: PLSQL_RESERVED_IF
				{
				mPLSQL_RESERVED_IF(); 

				}
				break;
			case 82 :
				// PLSQLLexer.g:1:1433: SQL92_RESERVED_IN
				{
				mSQL92_RESERVED_IN(); 

				}
				break;
			case 83 :
				// PLSQLLexer.g:1:1451: PLSQL_RESERVED_INDEX
				{
				mPLSQL_RESERVED_INDEX(); 

				}
				break;
			case 84 :
				// PLSQLLexer.g:1:1472: PLSQL_RESERVED_INDEXES
				{
				mPLSQL_RESERVED_INDEXES(); 

				}
				break;
			case 85 :
				// PLSQLLexer.g:1:1495: SQL92_RESERVED_INSERT
				{
				mSQL92_RESERVED_INSERT(); 

				}
				break;
			case 86 :
				// PLSQLLexer.g:1:1517: SQL92_RESERVED_INTERSECT
				{
				mSQL92_RESERVED_INTERSECT(); 

				}
				break;
			case 87 :
				// PLSQLLexer.g:1:1542: SQL92_RESERVED_INTO
				{
				mSQL92_RESERVED_INTO(); 

				}
				break;
			case 88 :
				// PLSQLLexer.g:1:1562: SQL92_RESERVED_IS
				{
				mSQL92_RESERVED_IS(); 

				}
				break;
			case 89 :
				// PLSQLLexer.g:1:1580: SQL92_RESERVED_LIKE
				{
				mSQL92_RESERVED_LIKE(); 

				}
				break;
			case 90 :
				// PLSQLLexer.g:1:1600: PLSQL_RESERVED_LOCK
				{
				mPLSQL_RESERVED_LOCK(); 

				}
				break;
			case 91 :
				// PLSQLLexer.g:1:1620: PLSQL_RESERVED_MINUS
				{
				mPLSQL_RESERVED_MINUS(); 

				}
				break;
			case 92 :
				// PLSQLLexer.g:1:1641: PLSQL_RESERVED_MODE
				{
				mPLSQL_RESERVED_MODE(); 

				}
				break;
			case 93 :
				// PLSQLLexer.g:1:1661: PLSQL_RESERVED_NOCOMPRESS
				{
				mPLSQL_RESERVED_NOCOMPRESS(); 

				}
				break;
			case 94 :
				// PLSQLLexer.g:1:1687: SQL92_RESERVED_NOT
				{
				mSQL92_RESERVED_NOT(); 

				}
				break;
			case 95 :
				// PLSQLLexer.g:1:1706: PLSQL_RESERVED_NOWAIT
				{
				mPLSQL_RESERVED_NOWAIT(); 

				}
				break;
			case 96 :
				// PLSQLLexer.g:1:1728: SQL92_RESERVED_NULL
				{
				mSQL92_RESERVED_NULL(); 

				}
				break;
			case 97 :
				// PLSQLLexer.g:1:1748: SQL92_RESERVED_OF
				{
				mSQL92_RESERVED_OF(); 

				}
				break;
			case 98 :
				// PLSQLLexer.g:1:1766: SQL92_RESERVED_ON
				{
				mSQL92_RESERVED_ON(); 

				}
				break;
			case 99 :
				// PLSQLLexer.g:1:1784: SQL92_RESERVED_OPTION
				{
				mSQL92_RESERVED_OPTION(); 

				}
				break;
			case 100 :
				// PLSQLLexer.g:1:1806: SQL92_RESERVED_OR
				{
				mSQL92_RESERVED_OR(); 

				}
				break;
			case 101 :
				// PLSQLLexer.g:1:1824: SQL92_RESERVED_ORDER
				{
				mSQL92_RESERVED_ORDER(); 

				}
				break;
			case 102 :
				// PLSQLLexer.g:1:1845: SQL92_RESERVED_OVERLAPS
				{
				mSQL92_RESERVED_OVERLAPS(); 

				}
				break;
			case 103 :
				// PLSQLLexer.g:1:1869: SQL92_RESERVED_PRIOR
				{
				mSQL92_RESERVED_PRIOR(); 

				}
				break;
			case 104 :
				// PLSQLLexer.g:1:1890: SQL92_RESERVED_PROCEDURE
				{
				mSQL92_RESERVED_PROCEDURE(); 

				}
				break;
			case 105 :
				// PLSQLLexer.g:1:1915: SQL92_RESERVED_PUBLIC
				{
				mSQL92_RESERVED_PUBLIC(); 

				}
				break;
			case 106 :
				// PLSQLLexer.g:1:1937: PLSQL_RESERVED_RESOURCE
				{
				mPLSQL_RESERVED_RESOURCE(); 

				}
				break;
			case 107 :
				// PLSQLLexer.g:1:1961: SQL92_RESERVED_REVOKE
				{
				mSQL92_RESERVED_REVOKE(); 

				}
				break;
			case 108 :
				// PLSQLLexer.g:1:1983: SQL92_RESERVED_SELECT
				{
				mSQL92_RESERVED_SELECT(); 

				}
				break;
			case 109 :
				// PLSQLLexer.g:1:2005: PLSQL_RESERVED_SHARE
				{
				mPLSQL_RESERVED_SHARE(); 

				}
				break;
			case 110 :
				// PLSQLLexer.g:1:2026: SQL92_RESERVED_SIZE
				{
				mSQL92_RESERVED_SIZE(); 

				}
				break;
			case 111 :
				// PLSQLLexer.g:1:2046: PLSQL_RESERVED_START
				{
				mPLSQL_RESERVED_START(); 

				}
				break;
			case 112 :
				// PLSQLLexer.g:1:2067: PLSQL_RESERVED_TABAUTH
				{
				mPLSQL_RESERVED_TABAUTH(); 

				}
				break;
			case 113 :
				// PLSQLLexer.g:1:2090: SQL92_RESERVED_TABLE
				{
				mSQL92_RESERVED_TABLE(); 

				}
				break;
			case 114 :
				// PLSQLLexer.g:1:2111: SQL92_RESERVED_THE
				{
				mSQL92_RESERVED_THE(); 

				}
				break;
			case 115 :
				// PLSQLLexer.g:1:2130: SQL92_RESERVED_THEN
				{
				mSQL92_RESERVED_THEN(); 

				}
				break;
			case 116 :
				// PLSQLLexer.g:1:2150: SQL92_RESERVED_TO
				{
				mSQL92_RESERVED_TO(); 

				}
				break;
			case 117 :
				// PLSQLLexer.g:1:2168: SQL92_RESERVED_TRUE
				{
				mSQL92_RESERVED_TRUE(); 

				}
				break;
			case 118 :
				// PLSQLLexer.g:1:2188: SQL92_RESERVED_UNION
				{
				mSQL92_RESERVED_UNION(); 

				}
				break;
			case 119 :
				// PLSQLLexer.g:1:2209: SQL92_RESERVED_UNIQUE
				{
				mSQL92_RESERVED_UNIQUE(); 

				}
				break;
			case 120 :
				// PLSQLLexer.g:1:2231: SQL92_RESERVED_UPDATE
				{
				mSQL92_RESERVED_UPDATE(); 

				}
				break;
			case 121 :
				// PLSQLLexer.g:1:2253: SQL92_RESERVED_VALUES
				{
				mSQL92_RESERVED_VALUES(); 

				}
				break;
			case 122 :
				// PLSQLLexer.g:1:2275: SQL92_RESERVED_VIEW
				{
				mSQL92_RESERVED_VIEW(); 

				}
				break;
			case 123 :
				// PLSQLLexer.g:1:2295: PLSQL_RESERVED_VIEWS
				{
				mPLSQL_RESERVED_VIEWS(); 

				}
				break;
			case 124 :
				// PLSQLLexer.g:1:2316: SQL92_RESERVED_WHEN
				{
				mSQL92_RESERVED_WHEN(); 

				}
				break;
			case 125 :
				// PLSQLLexer.g:1:2336: SQL92_RESERVED_WHERE
				{
				mSQL92_RESERVED_WHERE(); 

				}
				break;
			case 126 :
				// PLSQLLexer.g:1:2357: SQL92_RESERVED_WITH
				{
				mSQL92_RESERVED_WITH(); 

				}
				break;
			case 127 :
				// PLSQLLexer.g:1:2377: PLSQL_NON_RESERVED_CAST
				{
				mPLSQL_NON_RESERVED_CAST(); 

				}
				break;
			case 128 :
				// PLSQLLexer.g:1:2401: PLSQL_NON_RESERVED_MULTISET
				{
				mPLSQL_NON_RESERVED_MULTISET(); 

				}
				break;
			case 129 :
				// PLSQLLexer.g:1:2429: PLSQL_NON_RESERVED_USING
				{
				mPLSQL_NON_RESERVED_USING(); 

				}
				break;
			case 130 :
				// PLSQLLexer.g:1:2454: PLSQL_NON_RESERVED_MODEL
				{
				mPLSQL_NON_RESERVED_MODEL(); 

				}
				break;
			case 131 :
				// PLSQLLexer.g:1:2479: PLSQL_NON_RESERVED_ELSIF
				{
				mPLSQL_NON_RESERVED_ELSIF(); 

				}
				break;
			case 132 :
				// PLSQLLexer.g:1:2504: PLSQL_NON_RESERVED_PIVOT
				{
				mPLSQL_NON_RESERVED_PIVOT(); 

				}
				break;
			case 133 :
				// PLSQLLexer.g:1:2529: PLSQL_NON_RESERVED_UNPIVOT
				{
				mPLSQL_NON_RESERVED_UNPIVOT(); 

				}
				break;
			case 134 :
				// PLSQLLexer.g:1:2556: REGULAR_ID
				{
				mREGULAR_ID(); 

				}
				break;
			case 135 :
				// PLSQLLexer.g:1:2567: ZV
				{
				mZV(); 

				}
				break;

		}
	}


	protected DFA41 dfa41 = new DFA41(this);
	static final String DFA41_eotS =
		"\1\uffff\1\65\3\64\1\76\1\uffff\1\64\5\uffff\1\101\2\uffff\1\102\1\104"+
		"\1\106\2\uffff\1\111\1\113\1\114\1\115\1\116\1\120\5\uffff\24\64\2\uffff"+
		"\1\65\1\uffff\3\64\1\u0090\25\uffff\5\64\1\u009a\25\64\1\u00b8\1\u00bc"+
		"\1\u00bd\5\64\1\u00c3\1\u00c4\1\64\1\u00c7\10\64\1\u00d1\10\64\1\uffff"+
		"\1\64\1\u00dc\4\64\1\uffff\4\64\1\u00e6\1\64\1\u00e8\1\u00e9\1\u00ea\1"+
		"\uffff\21\64\1\u00ff\4\64\1\u0105\6\64\1\uffff\3\64\2\uffff\5\64\2\uffff"+
		"\2\64\1\uffff\10\64\1\u0121\1\uffff\12\64\1\uffff\1\64\1\u012f\7\64\1"+
		"\uffff\1\64\3\uffff\1\u0138\1\u0139\11\64\1\u0143\3\64\1\u0147\1\64\1"+
		"\u0149\1\u014a\1\64\1\uffff\5\64\1\uffff\1\u0151\1\u0152\7\64\1\u015a"+
		"\1\u015b\1\u015c\1\64\1\u015f\10\64\1\u0168\3\64\1\u016c\1\uffff\1\u016d"+
		"\6\64\1\u0175\1\u0176\1\64\1\u0178\2\64\1\uffff\1\u017b\3\64\1\u017f\1"+
		"\64\1\u0181\1\u0182\2\uffff\1\u0183\4\64\1\u0188\3\64\1\uffff\3\64\1\uffff"+
		"\1\64\2\uffff\1\u0190\3\64\1\u0194\1\u0195\2\uffff\1\u0196\1\u0197\2\64"+
		"\1\u019b\2\64\3\uffff\1\u019e\1\u019f\1\uffff\2\64\1\u01a2\4\64\1\u01a7"+
		"\1\uffff\1\u01a8\1\64\1\u01aa\2\uffff\1\u01ab\3\64\1\u01af\1\64\1\u01b1"+
		"\2\uffff\1\u01b2\1\uffff\1\64\1\u01b4\1\uffff\3\64\1\uffff\1\u01b8\3\uffff"+
		"\4\64\1\uffff\1\u01bd\1\64\1\u01bf\2\64\1\u01c2\1\64\1\uffff\2\64\1\u01c6"+
		"\4\uffff\1\u01c7\2\64\1\uffff\1\u01ca\1\64\2\uffff\1\64\1\u01cd\1\uffff"+
		"\2\64\1\u01d0\1\u01d1\2\uffff\1\64\2\uffff\1\u01d3\1\64\1\u01d5\1\uffff"+
		"\1\u01d6\2\uffff\1\64\1\uffff\1\u01d8\1\uffff\1\64\1\uffff\1\64\1\u01db"+
		"\1\64\1\u01de\1\uffff\1\u01df\1\uffff\1\u01e0\1\u01e1\1\uffff\3\64\2\uffff"+
		"\1\64\1\u01e6\1\uffff\2\64\1\uffff\2\64\2\uffff\1\u01eb\1\uffff\1\u01ec"+
		"\2\uffff\1\64\1\uffff\1\64\1\u01ef\1\uffff\1\u01f0\1\64\4\uffff\1\u01f2"+
		"\3\64\1\uffff\1\64\1\u01f7\1\u01f8\1\u01f9\2\uffff\1\64\1\u01fb\2\uffff"+
		"\1\64\1\uffff\1\u01fd\1\u01fe\1\64\1\u0200\3\uffff\1\u0201\1\uffff\1\64"+
		"\2\uffff\1\u0203\2\uffff\1\64\1\uffff\3\64\1\u0208\1\uffff";
	static final String DFA41_eofS =
		"\u0209\uffff";
	static final String DFA41_minS =
		"\1\11\1\56\3\47\1\60\1\uffff\1\47\5\uffff\1\52\2\uffff\1\52\1\41\1\42"+
		"\2\uffff\5\75\1\174\5\uffff\1\151\1\154\1\47\2\141\1\154\1\141\1\157\1"+
		"\141\1\144\2\151\1\47\1\146\2\145\1\141\1\156\1\141\1\150\2\uffff\1\56"+
		"\1\uffff\1\143\1\154\1\147\1\43\25\uffff\1\151\1\142\1\166\1\154\1\144"+
		"\1\43\1\163\1\145\1\165\1\154\1\141\1\162\1\164\1\143\1\163\1\157\1\163"+
		"\1\144\1\143\1\154\1\164\1\162\1\157\1\164\1\141\1\166\1\145\3\43\1\153"+
		"\1\143\1\156\1\144\1\154\2\43\1\164\1\43\1\145\1\163\1\154\1\141\1\172"+
		"\1\141\1\142\1\145\1\43\1\165\1\151\1\144\1\151\1\154\2\145\1\164\1\uffff"+
		"\1\157\1\43\1\141\1\154\1\151\1\167\1\uffff\1\143\1\157\1\154\1\157\1"+
		"\43\1\145\3\43\1\uffff\1\145\1\143\1\163\1\141\1\160\1\156\1\163\1\141"+
		"\1\162\1\145\1\154\1\141\1\145\1\143\1\164\1\160\1\145\1\43\1\145\2\163"+
		"\1\143\1\43\1\155\1\157\1\156\1\165\1\151\1\156\1\uffff\3\145\2\uffff"+
		"\1\145\1\153\1\165\1\145\1\164\2\uffff\1\151\1\145\1\uffff\1\162\2\157"+
		"\1\145\1\162\1\145\1\162\1\141\1\43\1\uffff\1\145\1\157\1\151\1\141\1"+
		"\156\1\165\1\167\1\156\1\150\1\155\1\uffff\1\151\1\43\1\156\1\145\1\160"+
		"\1\145\1\162\1\151\1\164\1\uffff\1\162\3\uffff\2\43\1\153\1\164\1\165"+
		"\1\162\1\145\1\150\1\164\1\145\1\157\1\43\1\141\1\165\1\164\1\43\1\151"+
		"\2\43\1\146\1\uffff\1\160\1\165\1\164\1\145\1\150\1\uffff\2\43\1\164\1"+
		"\160\1\156\1\164\1\170\2\162\3\43\1\163\1\43\1\151\1\157\1\162\1\154\1"+
		"\165\1\153\1\143\1\145\1\43\1\164\1\165\1\145\1\43\1\uffff\1\43\1\156"+
		"\1\165\1\166\1\164\1\147\1\145\2\43\1\145\1\43\1\160\1\164\1\uffff\1\43"+
		"\1\145\1\164\1\144\1\43\1\143\2\43\2\uffff\1\43\1\145\1\164\1\145\1\143"+
		"\1\43\1\145\1\156\1\162\1\uffff\1\162\1\154\1\145\1\uffff\1\156\2\uffff"+
		"\1\43\1\164\2\163\2\43\2\uffff\2\43\1\147\1\151\1\43\1\164\1\163\3\uffff"+
		"\2\43\1\uffff\1\163\1\156\1\43\1\141\1\162\1\145\1\164\1\43\1\uffff\1"+
		"\43\1\164\1\43\2\uffff\1\43\1\145\1\157\1\145\1\43\1\163\1\43\2\uffff"+
		"\1\43\1\uffff\1\162\1\43\1\uffff\1\156\1\11\1\165\1\uffff\1\43\3\uffff"+
		"\1\162\1\150\1\163\1\164\1\uffff\1\43\1\164\1\43\1\145\1\164\1\43\1\143"+
		"\1\uffff\2\151\1\43\4\uffff\1\43\1\146\1\163\1\uffff\1\43\1\145\2\uffff"+
		"\1\145\1\43\1\uffff\1\160\1\143\2\43\2\uffff\1\150\2\uffff\1\43\1\164"+
		"\1\43\1\uffff\1\43\2\uffff\1\145\1\uffff\1\43\1\uffff\1\162\1\uffff\1"+
		"\163\1\43\1\163\1\43\1\uffff\1\43\1\uffff\2\43\1\uffff\1\164\1\157\1\166"+
		"\2\uffff\1\151\1\43\1\uffff\1\143\1\164\1\uffff\1\163\1\145\2\uffff\1"+
		"\43\1\uffff\1\43\2\uffff\1\163\1\uffff\1\145\1\43\1\uffff\1\43\1\142\4"+
		"\uffff\1\43\1\156\2\145\1\uffff\1\164\3\43\2\uffff\1\163\1\43\2\uffff"+
		"\1\171\1\uffff\2\43\1\144\1\43\3\uffff\1\43\1\uffff\1\137\2\uffff\1\43"+
		"\2\uffff\1\162\1\uffff\2\157\1\164\1\43\1\uffff";
	static final String DFA41_maxS =
		"\1\176\1\71\1\165\1\171\1\47\1\71\1\uffff\1\47\5\uffff\1\52\2\uffff\1"+
		"\52\1\41\1\172\2\uffff\1\76\4\75\1\174\5\uffff\1\165\1\163\1\47\1\165"+
		"\1\162\1\170\2\162\1\141\1\163\1\157\1\165\1\47\1\166\1\145\1\164\1\162"+
		"\1\163\2\151\2\uffff\1\56\1\uffff\1\167\1\154\1\164\1\172\25\uffff\1\157"+
		"\1\142\1\166\1\164\1\171\1\172\1\163\1\145\1\165\1\156\1\145\1\162\1\164"+
		"\2\163\1\157\1\163\1\144\1\151\1\154\1\164\1\162\1\157\1\164\1\157\1\166"+
		"\1\145\3\172\1\153\1\143\1\156\1\144\1\154\2\172\1\164\1\172\1\145\1\166"+
		"\1\154\1\141\1\172\1\141\1\142\1\145\1\172\1\165\1\160\1\144\1\151\1\154"+
		"\2\145\1\164\1\uffff\1\157\1\172\1\141\1\154\1\151\1\167\1\uffff\1\155"+
		"\1\157\1\154\1\157\1\172\1\145\3\172\1\uffff\1\164\1\143\1\163\1\141\1"+
		"\160\1\156\1\163\1\141\1\163\1\145\1\154\1\141\1\145\1\143\1\164\1\160"+
		"\1\151\1\172\1\154\2\163\1\143\1\172\1\155\1\157\1\156\1\165\1\151\1\156"+
		"\1\uffff\2\145\1\157\2\uffff\1\145\1\153\1\165\1\145\1\164\2\uffff\1\151"+
		"\1\145\1\uffff\1\162\2\157\1\145\1\162\1\145\1\162\1\154\1\172\1\uffff"+
		"\1\145\1\161\1\151\1\141\1\156\1\165\1\167\1\162\1\150\1\155\1\uffff\1"+
		"\151\1\172\1\156\1\145\1\160\1\145\1\162\1\151\1\164\1\uffff\1\162\3\uffff"+
		"\2\172\1\153\1\164\1\165\1\162\1\145\1\150\1\164\1\145\1\157\1\172\1\141"+
		"\1\165\1\164\1\172\1\151\2\172\1\146\1\uffff\1\160\1\165\1\164\1\145\1"+
		"\150\1\uffff\2\172\1\164\1\160\1\156\1\164\1\170\2\162\3\172\1\163\1\172"+
		"\1\151\1\157\1\162\1\154\1\165\1\153\1\143\1\145\1\172\1\164\1\165\1\145"+
		"\1\172\1\uffff\1\172\1\156\1\165\1\166\1\164\1\147\1\145\2\172\1\145\1"+
		"\172\1\160\1\164\1\uffff\1\172\1\145\1\164\1\144\1\172\1\143\2\172\2\uffff"+
		"\1\172\1\145\1\164\1\145\1\143\1\172\1\145\1\156\1\162\1\uffff\1\162\1"+
		"\154\1\145\1\uffff\1\156\2\uffff\1\172\1\164\2\163\2\172\2\uffff\2\172"+
		"\1\147\1\151\1\172\1\164\1\163\3\uffff\2\172\1\uffff\1\163\1\156\1\172"+
		"\1\141\1\162\1\145\1\164\1\172\1\uffff\1\172\1\164\1\172\2\uffff\1\172"+
		"\1\145\1\157\1\145\1\172\1\163\1\172\2\uffff\1\172\1\uffff\1\162\1\172"+
		"\1\uffff\1\156\1\40\1\165\1\uffff\1\172\3\uffff\1\162\1\150\1\163\1\164"+
		"\1\uffff\1\172\1\164\1\172\1\145\1\164\1\172\1\143\1\uffff\2\151\1\172"+
		"\4\uffff\1\172\1\146\1\163\1\uffff\1\172\1\145\2\uffff\1\145\1\172\1\uffff"+
		"\1\160\1\143\2\172\2\uffff\1\150\2\uffff\1\172\1\164\1\172\1\uffff\1\172"+
		"\2\uffff\1\145\1\uffff\1\172\1\uffff\1\162\1\uffff\1\163\1\172\1\163\1"+
		"\172\1\uffff\1\172\1\uffff\2\172\1\uffff\1\164\1\157\1\166\2\uffff\1\151"+
		"\1\172\1\uffff\1\143\1\164\1\uffff\1\163\1\145\2\uffff\1\172\1\uffff\1"+
		"\172\2\uffff\1\163\1\uffff\1\145\1\172\1\uffff\1\172\1\142\4\uffff\1\172"+
		"\1\156\2\145\1\uffff\1\164\3\172\2\uffff\1\163\1\172\2\uffff\1\171\1\uffff"+
		"\2\172\1\144\1\172\3\uffff\1\172\1\uffff\1\137\2\uffff\1\172\2\uffff\1"+
		"\162\1\uffff\2\157\1\164\1\172\1\uffff";
	static final String DFA41_acceptS =
		"\6\uffff\1\7\1\uffff\1\11\1\12\1\13\1\14\1\15\1\uffff\1\20\1\21\3\uffff"+
		"\1\25\1\27\6\uffff\1\42\1\43\1\44\1\45\1\46\24\uffff\1\u0086\1\6\1\uffff"+
		"\1\2\4\uffff\1\3\1\4\1\5\1\10\1\16\1\17\1\22\1\u0087\1\23\1\24\1\26\1"+
		"\30\1\33\1\31\1\32\1\37\1\36\1\34\1\35\1\40\1\41\70\uffff\1\1\6\uffff"+
		"\1\60\11\uffff\1\54\35\uffff\1\121\3\uffff\1\122\1\130\5\uffff\1\141\1"+
		"\142\2\uffff\1\144\11\uffff\1\164\12\uffff\1\136\11\uffff\1\50\1\uffff"+
		"\1\52\1\53\1\55\24\uffff\1\104\5\uffff\1\112\33\uffff\1\162\15\uffff\1"+
		"\140\10\uffff\1\61\1\177\11\uffff\1\74\3\uffff\1\100\1\uffff\1\102\1\103"+
		"\6\uffff\1\113\1\114\7\uffff\1\127\1\131\1\132\2\uffff\1\134\10\uffff"+
		"\1\156\3\uffff\1\163\1\165\7\uffff\1\172\1\174\1\uffff\1\176\2\uffff\1"+
		"\56\3\uffff\1\147\1\uffff\1\u0084\1\51\1\62\4\uffff\1\70\7\uffff\1\u0083"+
		"\3\uffff\1\110\1\111\1\115\1\116\3\uffff\1\123\2\uffff\1\133\1\u0082\2"+
		"\uffff\1\145\4\uffff\1\155\1\157\1\uffff\1\161\1\166\3\uffff\1\u0081\1"+
		"\uffff\1\173\1\175\1\uffff\1\137\1\uffff\1\47\1\uffff\1\151\4\uffff\1"+
		"\71\1\uffff\1\73\2\uffff\1\77\3\uffff\1\107\1\117\2\uffff\1\125\2\uffff"+
		"\1\143\2\uffff\1\153\1\154\1\uffff\1\167\1\uffff\1\170\1\171\1\uffff\1"+
		"\57\2\uffff\1\64\2\uffff\1\66\1\72\1\75\1\76\4\uffff\1\124\4\uffff\1\160"+
		"\1\u0085\2\uffff\1\63\1\65\1\uffff\1\101\4\uffff\1\u0080\1\146\1\152\1"+
		"\uffff\1\150\1\uffff\1\105\1\106\1\uffff\1\126\1\135\1\uffff\1\120\4\uffff"+
		"\1\67";
	static final String DFA41_specialS =
		"\u0209\uffff}>";
	static final String[] DFA41_transitionS = {
			"\2\37\2\uffff\1\37\22\uffff\1\37\1\27\1\10\2\uffff\1\11\1\12\1\6\1\13"+
			"\1\14\1\15\1\16\1\17\1\37\1\5\1\20\12\1\1\22\1\24\1\25\1\33\1\26\1\23"+
			"\1\21\1\64\1\42\13\64\1\54\2\64\1\7\6\64\1\4\2\64\1\34\1\uffff\1\35\1"+
			"\30\1\36\1\uffff\1\41\1\3\1\43\1\44\1\45\1\46\1\47\1\50\1\51\2\64\1\52"+
			"\1\53\1\2\1\55\1\40\1\7\1\56\1\57\1\60\1\61\1\62\1\63\1\4\2\64\1\uffff"+
			"\1\32\1\uffff\1\31",
			"\1\66\1\uffff\12\1",
			"\1\67\107\uffff\1\70\5\uffff\1\71",
			"\1\74\75\uffff\1\72\23\uffff\1\73",
			"\1\75",
			"\12\65",
			"",
			"\1\77",
			"",
			"",
			"",
			"",
			"",
			"\1\100",
			"",
			"",
			"\1\37",
			"\1\103",
			"\1\23\15\uffff\12\23\3\uffff\1\105\3\uffff\32\23\6\uffff\32\23",
			"",
			"",
			"\1\107\1\110",
			"\1\112",
			"\1\110",
			"\1\110",
			"\1\110",
			"\1\117",
			"",
			"",
			"",
			"",
			"",
			"\1\123\10\uffff\1\121\2\uffff\1\122",
			"\1\124\1\uffff\1\125\4\uffff\1\126",
			"\1\74",
			"\1\127\6\uffff\1\130\3\uffff\1\131\2\uffff\1\132\2\uffff\1\133\2\uffff"+
			"\1\134",
			"\1\135\3\uffff\1\136\3\uffff\1\137\10\uffff\1\140",
			"\1\141\1\uffff\1\142\11\uffff\1\143",
			"\1\144\3\uffff\1\145\11\uffff\1\146\2\uffff\1\147",
			"\1\150\2\uffff\1\151",
			"\1\152",
			"\1\153\1\uffff\1\154\7\uffff\1\155\4\uffff\1\156",
			"\1\157\5\uffff\1\160",
			"\1\161\5\uffff\1\162\5\uffff\1\163",
			"\1\67",
			"\1\164\7\uffff\1\165\1\uffff\1\166\1\uffff\1\167\3\uffff\1\170",
			"\1\171",
			"\1\172\2\uffff\1\173\1\174\12\uffff\1\175",
			"\1\176\6\uffff\1\177\6\uffff\1\u0080\2\uffff\1\u0081",
			"\1\u0082\1\uffff\1\u0083\2\uffff\1\u0084",
			"\1\u0085\7\uffff\1\u0086",
			"\1\u0087\1\u0088",
			"",
			"",
			"\1\u0089",
			"",
			"\1\u008a\20\uffff\1\u008b\2\uffff\1\u008c",
			"\1\u008d",
			"\1\u008e\14\uffff\1\u008f",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"",
			"\1\u0092\5\uffff\1\u0091",
			"\1\u0093",
			"\1\u0094",
			"\1\u0095\7\uffff\1\u0096",
			"\1\u0097\24\uffff\1\u0098",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\2\64\1\u0099"+
			"\27\64",
			"\1\u009b",
			"\1\u009c",
			"\1\u009d",
			"\1\u009e\1\u009f\1\u00a0",
			"\1\u00a1\3\uffff\1\u00a2",
			"\1\u00a3",
			"\1\u00a4",
			"\1\u00a5\2\uffff\1\u00a6\5\uffff\1\u00a7\6\uffff\1\u00a8",
			"\1\u00a9",
			"\1\u00aa",
			"\1\u00ab",
			"\1\u00ac",
			"\1\u00ad\5\uffff\1\u00ae",
			"\1\u00af",
			"\1\u00b0",
			"\1\u00b1",
			"\1\u00b2",
			"\1\u00b3",
			"\1\u00b4\15\uffff\1\u00b5",
			"\1\u00b6",
			"\1\u00b7",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\3\64\1\u00b9"+
			"\16\64\1\u00ba\1\u00bb\6\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u00be",
			"\1\u00bf",
			"\1\u00c0",
			"\1\u00c1",
			"\1\u00c2",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u00c5",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\3\64\1\u00c6"+
			"\26\64",
			"\1\u00c8",
			"\1\u00c9\2\uffff\1\u00ca",
			"\1\u00cb",
			"\1\u00cc",
			"\1\u00cd",
			"\1\u00ce",
			"\1\u00cf",
			"\1\u00d0",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u00d2",
			"\1\u00d3\6\uffff\1\u00d4",
			"\1\u00d5",
			"\1\u00d6",
			"\1\u00d7",
			"\1\u00d8",
			"\1\u00d9",
			"\1\u00da",
			"",
			"\1\u00db",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u00dd",
			"\1\u00de",
			"\1\u00df",
			"\1\u00e0",
			"",
			"\1\u00e2\11\uffff\1\u00e1",
			"\1\u00e3",
			"\1\u00e4",
			"\1\u00e5",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u00e7",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u00eb\16\uffff\1\u00ec",
			"\1\u00ed",
			"\1\u00ee",
			"\1\u00ef",
			"\1\u00f0",
			"\1\u00f1",
			"\1\u00f2",
			"\1\u00f3",
			"\1\u00f4\1\u00f5",
			"\1\u00f6",
			"\1\u00f7",
			"\1\u00f8",
			"\1\u00f9",
			"\1\u00fa",
			"\1\u00fb",
			"\1\u00fc",
			"\1\u00fd\3\uffff\1\u00fe",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0100\6\uffff\1\u0101",
			"\1\u0102",
			"\1\u0103",
			"\1\u0104",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0106",
			"\1\u0107",
			"\1\u0108",
			"\1\u0109",
			"\1\u010a",
			"\1\u010b",
			"",
			"\1\u010c",
			"\1\u010d",
			"\1\u010e\11\uffff\1\u010f",
			"",
			"",
			"\1\u0110",
			"\1\u0111",
			"\1\u0112",
			"\1\u0113",
			"\1\u0114",
			"",
			"",
			"\1\u0115",
			"\1\u0116",
			"",
			"\1\u0117",
			"\1\u0118",
			"\1\u0119",
			"\1\u011a",
			"\1\u011b",
			"\1\u011c",
			"\1\u011d",
			"\1\u011e\12\uffff\1\u011f",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\15\64\1\u0120"+
			"\14\64",
			"",
			"\1\u0122",
			"\1\u0123\1\uffff\1\u0124",
			"\1\u0125",
			"\1\u0126",
			"\1\u0127",
			"\1\u0128",
			"\1\u0129",
			"\1\u012a\3\uffff\1\u012b",
			"\1\u012c",
			"\1\u012d",
			"",
			"\1\u012e",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0130",
			"\1\u0131",
			"\1\u0132",
			"\1\u0133",
			"\1\u0134",
			"\1\u0135",
			"\1\u0136",
			"",
			"\1\u0137",
			"",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u013a",
			"\1\u013b",
			"\1\u013c",
			"\1\u013d",
			"\1\u013e",
			"\1\u013f",
			"\1\u0140",
			"\1\u0141",
			"\1\u0142",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0144",
			"\1\u0145",
			"\1\u0146",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0148",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u014b",
			"",
			"\1\u014c",
			"\1\u014d",
			"\1\u014e",
			"\1\u014f",
			"\1\u0150",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0153",
			"\1\u0154",
			"\1\u0155",
			"\1\u0156",
			"\1\u0157",
			"\1\u0158",
			"\1\u0159",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u015d",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\13\64\1\u015e"+
			"\16\64",
			"\1\u0160",
			"\1\u0161",
			"\1\u0162",
			"\1\u0163",
			"\1\u0164",
			"\1\u0165",
			"\1\u0166",
			"\1\u0167",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0169",
			"\1\u016a",
			"\1\u016b",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u016e",
			"\1\u016f",
			"\1\u0170",
			"\1\u0171",
			"\1\u0172",
			"\1\u0173",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\22\64\1\u0174"+
			"\7\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0177",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0179",
			"\1\u017a",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u017c",
			"\1\u017d",
			"\1\u017e",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0180",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0184",
			"\1\u0185",
			"\1\u0186",
			"\1\u0187",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0189",
			"\1\u018a",
			"\1\u018b",
			"",
			"\1\u018c",
			"\1\u018d",
			"\1\u018e",
			"",
			"\1\u018f",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0191",
			"\1\u0192",
			"\1\u0193",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u0198",
			"\1\u0199",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\4\64\1\u019a"+
			"\25\64",
			"\1\u019c",
			"\1\u019d",
			"",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01a0",
			"\1\u01a1",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01a3",
			"\1\u01a4",
			"\1\u01a5",
			"\1\u01a6",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01a9",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01ac",
			"\1\u01ad",
			"\1\u01ae",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01b0",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01b3",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01b5",
			"\1\u01b6\26\uffff\1\u01b6",
			"\1\u01b7",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"",
			"\1\u01b9",
			"\1\u01ba",
			"\1\u01bb",
			"\1\u01bc",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01be",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01c0",
			"\1\u01c1",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01c3",
			"",
			"\1\u01c4",
			"\1\u01c5",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01c8",
			"\1\u01c9",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01cb",
			"",
			"",
			"\1\u01cc",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01ce",
			"\1\u01cf",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u01d2",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01d4",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u01d7",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01d9",
			"",
			"\1\u01da",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01dc",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\u01dd\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01e2",
			"\1\u01e3",
			"\1\u01e4",
			"",
			"",
			"\1\u01e5",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u01e7",
			"\1\u01e8",
			"",
			"\1\u01e9",
			"\1\u01ea",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u01ed",
			"",
			"\1\u01ee",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01f1",
			"",
			"",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01f3",
			"\1\u01f4",
			"\1\u01f5",
			"",
			"\1\u01f6",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u01fa",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u01fc",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"\1\u01ff",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"\1\u0202",
			"",
			"",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			"",
			"",
			"\1\u0204",
			"",
			"\1\u0205",
			"\1\u0206",
			"\1\u0207",
			"\2\64\13\uffff\12\64\7\uffff\32\64\4\uffff\1\64\1\uffff\32\64",
			""
	};

	static final short[] DFA41_eot = DFA.unpackEncodedString(DFA41_eotS);
	static final short[] DFA41_eof = DFA.unpackEncodedString(DFA41_eofS);
	static final char[] DFA41_min = DFA.unpackEncodedStringToUnsignedChars(DFA41_minS);
	static final char[] DFA41_max = DFA.unpackEncodedStringToUnsignedChars(DFA41_maxS);
	static final short[] DFA41_accept = DFA.unpackEncodedString(DFA41_acceptS);
	static final short[] DFA41_special = DFA.unpackEncodedString(DFA41_specialS);
	static final short[][] DFA41_transition;

	static {
		int numStates = DFA41_transitionS.length;
		DFA41_transition = new short[numStates][];
		for (int i=0; i<numStates; i++) {
			DFA41_transition[i] = DFA.unpackEncodedString(DFA41_transitionS[i]);
		}
	}

	protected class DFA41 extends DFA {

		public DFA41(BaseRecognizer recognizer) {
			this.recognizer = recognizer;
			this.decisionNumber = 41;
			this.eot = DFA41_eot;
			this.eof = DFA41_eof;
			this.min = DFA41_min;
			this.max = DFA41_max;
			this.accept = DFA41_accept;
			this.special = DFA41_special;
			this.transition = DFA41_transition;
		}
		@Override
		public String getDescription() {
			return "1:1: Tokens : ( FOR_NOTATION | NATIONAL_CHAR_STRING_LIT | BIT_STRING_LIT | HEX_STRING_LIT | PERIOD | EXACT_NUM_LIT | CHAR_STRING | CHAR_STRING_PERL | DELIMITED_ID | PERCENT | AMPERSAND | LEFT_PAREN | RIGHT_PAREN | DOUBLE_ASTERISK | ASTERISK | PLUS_SIGN | COMMA | SOLIDUS | AT_SIGN | ASSIGN_OP | BINDVAR | COLON | SEMICOLON | LESS_THAN_OR_EQUALS_OP | LESS_THAN_OP | GREATER_THAN_OR_EQUALS_OP | NOT_EQUAL_OP | CARRET_OPERATOR_PART | TILDE_OPERATOR_PART | EXCLAMATION_OPERATOR_PART | GREATER_THAN_OP | CONCATENATION_OP | VERTICAL_BAR | EQUALS_OP | LEFT_BRACKET | RIGHT_BRACKET | INTRODUCER | SEPARATOR | PROMPT | SQL92_RESERVED_ALL | SQL92_RESERVED_ALTER | SQL92_RESERVED_AND | SQL92_RESERVED_ANY | SQL92_RESERVED_AS | SQL92_RESERVED_ASC | SQL92_RESERVED_BEGIN | SQL92_RESERVED_BETWEEN | SQL92_RESERVED_BY | SQL92_RESERVED_CASE | SQL92_RESERVED_CHECK | PLSQL_RESERVED_CLUSTERS | PLSQL_RESERVED_COLAUTH | PLSQL_RESERVED_COMPRESS | SQL92_RESERVED_CONNECT | PLSQL_NON_RESERVED_CONNECT_BY_ROOT | PLSQL_RESERVED_CRASH | SQL92_RESERVED_CREATE | SQL92_RESERVED_CURRENT | SQL92_RESERVED_CURSOR | SQL92_RESERVED_DATE | SQL92_RESERVED_DECLARE | SQL92_RESERVED_DEFAULT | SQL92_RESERVED_DELETE | SQL92_RESERVED_DESC | SQL92_RESERVED_DISTINCT | SQL92_RESERVED_DROP | SQL92_RESERVED_ELSE | SQL92_RESERVED_END | SQL92_RESERVED_EXCEPTION | PLSQL_RESERVED_EXCLUSIVE | SQL92_RESERVED_EXISTS | SQL92_RESERVED_FALSE | SQL92_RESERVED_FETCH | SQL92_RESERVED_FOR | SQL92_RESERVED_FROM | SQL92_RESERVED_GOTO | SQL92_RESERVED_GRANT | SQL92_RESERVED_GROUP | SQL92_RESERVED_HAVING | PLSQL_RESERVED_IDENTIFIED | PLSQL_RESERVED_IF | SQL92_RESERVED_IN | PLSQL_RESERVED_INDEX | PLSQL_RESERVED_INDEXES | SQL92_RESERVED_INSERT | SQL92_RESERVED_INTERSECT | SQL92_RESERVED_INTO | SQL92_RESERVED_IS | SQL92_RESERVED_LIKE | PLSQL_RESERVED_LOCK | PLSQL_RESERVED_MINUS | PLSQL_RESERVED_MODE | PLSQL_RESERVED_NOCOMPRESS | SQL92_RESERVED_NOT | PLSQL_RESERVED_NOWAIT | SQL92_RESERVED_NULL | SQL92_RESERVED_OF | SQL92_RESERVED_ON | SQL92_RESERVED_OPTION | SQL92_RESERVED_OR | SQL92_RESERVED_ORDER | SQL92_RESERVED_OVERLAPS | SQL92_RESERVED_PRIOR | SQL92_RESERVED_PROCEDURE | SQL92_RESERVED_PUBLIC | PLSQL_RESERVED_RESOURCE | SQL92_RESERVED_REVOKE | SQL92_RESERVED_SELECT | PLSQL_RESERVED_SHARE | SQL92_RESERVED_SIZE | PLSQL_RESERVED_START | PLSQL_RESERVED_TABAUTH | SQL92_RESERVED_TABLE | SQL92_RESERVED_THE | SQL92_RESERVED_THEN | SQL92_RESERVED_TO | SQL92_RESERVED_TRUE | SQL92_RESERVED_UNION | SQL92_RESERVED_UNIQUE | SQL92_RESERVED_UPDATE | SQL92_RESERVED_VALUES | SQL92_RESERVED_VIEW | PLSQL_RESERVED_VIEWS | SQL92_RESERVED_WHEN | SQL92_RESERVED_WHERE | SQL92_RESERVED_WITH | PLSQL_NON_RESERVED_CAST | PLSQL_NON_RESERVED_MULTISET | PLSQL_NON_RESERVED_USING | PLSQL_NON_RESERVED_MODEL | PLSQL_NON_RESERVED_ELSIF | PLSQL_NON_RESERVED_PIVOT | PLSQL_NON_RESERVED_UNPIVOT | REGULAR_ID | ZV );";
		}
	}

}
